# Changelog ## [Unreleased] ## [3.4.0] Released on August 18, 2021 **Notice:** 3.4.x will be the last major release series of Eigen that will support c++03. ### Breaking changes * Using float or double for indexing matrices, vectors and arrays will now fail to compile * **Behavioral change:** `Transform::computeRotationScaling()` and `Transform::computeScalingRotation()` are now more continuous across degeneracies (see !349). ### New features * Add c++11 **`initializer_list` constructors** to Matrix and Array [\[doc\]](http://eigen.tuxfamily.org/dox-devel/group__TutorialMatrixClass.html#title3) * Add STL-compatible **iterators** for dense expressions [\[doc\]](http://eigen.tuxfamily.org/dox-devel/group__TutorialSTL.html). * New versatile API for sub-matrices, **slices**, and **indexed views** [\[doc\]](http://eigen.tuxfamily.org/dox-devel/group__TutorialSlicingIndexing.html). * Add C++11 **template aliases** for Matrix, Vector, and Array of common sizes, including generic `Vector` and `RowVector` aliases [\[doc\]](http://eigen.tuxfamily.org/dox-devel/group__matrixtypedefs.html). * New support for `bfloat16`. ### New backends * **Arm SVE:** fixed-length [Scalable Vector Extensions](https://developer.arm.com/Architectures/Scalable%20Vector%20Extensions) vectors for `uint32_t` and `float` are available. * **MIPS MSA:**: [MIPS SIMD Architecture (MSA)](https://www.mips.com/products/architectures/ase/simd/) * **AMD ROCm/HIP:** generic GPU backend that unifies support for [NVIDIA/CUDA](https://developer.nvidia.com/cuda-toolkit) and [AMD/HIP](https://rocmdocs.amd.com/en/latest/). * **Power 10 MMA:** initial support for [Power 10 matrix multiplication assist instructions](https://arxiv.org/pdf/2104.03142.pdf) for float32 and float64, real and complex. ### Improvements * Eigen now uses the c++11 **alignas** keyword for static alignment. Users targeting C++17 only and recent compilers (e.g., GCC>=7, clang>=5, MSVC>=19.12) will thus be able to completely forget about all [issues](http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html) related to static alignment, including `EIGEN_MAKE_ALIGNED_OPERATOR_NEW`. * Various performance improvements for products and Eigen's GEBP and GEMV kernels have been implemented: * By using half and quater-packets the performance of matrix multiplications of small to medium sized matrices has been improved * Eigen's GEMM now falls back to GEMV if it detects that a matrix is a run-time vector * The performance of matrix products using Arm Neon has been drastically improved (up to 20%) * Performance of many special cases of matrix products has been improved * Large speed up from blocked algorithm for `transposeInPlace`. * Speed up misc. operations by propagating compile-time sizes (col/row-wise reverse, PartialPivLU, and others) * Faster specialized SIMD kernels for small fixed-size inverse, LU decomposition, and determinant. * Improved or added vectorization of partial or slice reductions along the outer-dimension, for instance: `colmajor_mat.rowwise().mean()`. ### Elementwise math functions * Many functions are now implemented and vectorized in generic (backend-agnostic) form. * Many improvements to correctness, accuracy, and compatibility with c++ standard library. * Much improved implementation of `ldexp`. * Misc. fixes for corner cases, NaN/Inf inputs and singular points of many functions. * New implementation of the Payne-Hanek for argument reduction algorithm for `sin` and `cos` with huge arguments. * New faithfully rounded algorithm for `pow(x,y)`. * Speedups from (new or improved) vectorized versions of `pow`, `log`, `sin`, `cos`, `arg`, `pow`, `log2`, complex `sqrt`, `erf`, `expm1`, `logp1`, `logistic`, `rint`, `gamma` and `bessel` functions, and more. * Improved special function support (Bessel and gamma functions, `ndtri`, `erfc`, inverse hyperbolic functions and more) * New elementwise functions for `absolute_difference`, `rint`. ### Dense matrix decompositions and solvers * All dense linear solvers (i.e., Cholesky, *LU, *QR, CompleteOrthogonalDecomposition, *SVD) now inherit SolverBase and thus support `.transpose()`, `.adjoint()` and `.solve()` APIs. * SVD implementations now have an `info()` method for checking convergence. * Most decompositions now fail quickly when invalid inputs are detected. * Optimized the product of a `HouseholderSequence` with the identity, as well as the evaluation of a `HouseholderSequence` to a dense matrix using faster blocked product. * Fixed aliasing issues with in-place small matrix inversions. * Fixed several edge-cases with empty or zero inputs. ### Sparse matrix support, decompositions and solvers * Enabled assignment and addition with diagonal matrix expressions. * Support added for SuiteSparse KLU routines via the `KLUSupport` module. SuiteSparse must be installed to use this module. * `SparseCholesky` now works with row-major matrices. * Various bug fixes and performance improvements. ### Type support * Improved support for `half` * Native support added for ARM `__fp16`, CUDA/HIP `__half`, and `F16C` conversion intrinsics. * Better vectorization support added across all backends. * Improved bool support * Partial vectorization support added for boolean operations. * Significantly improved performance (x25) for logical operations with `Matrix` or `Tensor` of `bool`. * Improved support for custom types * More custom types work out-of-the-box (see #2201). ### Backend-specific improvements * **Arm NEON** * Now provides vectorization for `uint64_t`, `int64_t`, `uint32_t`, `int16_t`, `uint16_t`, `int16_t`, `int8_t`, and `uint8_t` * Emulates `bfloat16` support when using `Eigen::bfloat16` * Supports emulated and native `float16` when using `Eigen::half` * **SSE/AVX/AVX512** * General performance improvements and bugfixes. * Enabled AVX512 instructions by default if available. * New `std::complex`, `half`, and `bfloat16` vectorization support added. * Many missing packet functions added. * **Altivec/Power** * General performance improvement and bugfixes. * Enhanced vectorization of real and complex scalars. * Changes to the `gebp_kernel` specific to Altivec, using VSX implementation of the MMA instructions that gain speed improvements up to 4x for matrix-matrix products. * Dynamic dispatch for GCC greater than 10 enabling selection of MMA or VSX instructions based on `__builtin_cpu_supports`. * **GPU (CUDA and HIP)** * Several optimized math functions added, better support for `std::complex`. * Added option to disable CUDA entirely by defining `EIGEN_NO_CUDA`. * Many more functions can now be used in device code (e.g. comparisons, small matrix inversion). * **ZVector** * Vectorized `float` and `std::complex` support added. * Added z14 support. * **SYCL** * Redesigned SYCL implementation for use with the [https://eigen.tuxfamily.org/dox/unsupported/eigen_tensors.html Tensor] module, which can be enabled by defining `EIGEN_USE_SYCL`. * New generic memory model introduced used by `TensorDeviceSycl`. * Better integration with OpenCL devices. * Added many math function specializations. ### Miscellaneous API Changes * New `setConstant(...)` methods for preserving one dimension of a matrix by passing in `NoChange`. * Added `setUnit(Index i)` for vectors that sets the ''i'' th coefficient to one and all others to zero. * Added `transpose()`, `adjoint()`, `conjugate()` methods to `SelfAdjointView`. * Added `shiftLeft()` and `shiftRight()` coefficient-wise arithmetic shift functions to Arrays. * Enabled adding and subtracting of diagonal expressions. * Allow user-defined default cache sizes via defining `EIGEN_DEFAULT_L1_CACHE_SIZE`, ..., `EIGEN_DEFAULT_L3_CACHE_SIZE`. * Added `EIGEN_ALIGNOF(X)` macro for determining alignment of a provided variable. * Allow plugins for `VectorwiseOp` by defining a file `EIGEN_VECTORWISEOP_PLUGIN` (e.g. `-DEIGEN_VECTORWISEOP_PLUGIN=my_vectorwise_op_plugins.h`). * Allow disabling of IO operations by defining `EIGEN_NO_IO`. ### Improvement to NaN propagation * Improvements to NaN correctness for elementwise functions. * New `NaNPropagation` template argument to control whether NaNs are propagated or suppressed in elementwise `min/max` and corresponding reductions on `Array`, `Matrix`, and `Tensor`. ### New low-latency non-blocking ThreadPool module * Originally a part of the Tensor module, `Eigen::ThreadPool` is now separate and more portable, and forms the basis for multi-threading in TensorFlow, for example. ### Changes to Tensor module * Support for c++03 was officially dropped in Tensor module, since most of the code was written in c++11 anyway. This will prevent building the code for CUDA with older version of `nvcc`. * Performance optimizations of Tensor contraction * Speed up "outer-product-like" operations by parallelizing over the contraction dimension, using thread_local buffers and recursive work splitting. * Improved threading heuristics. * Support for fusing element-wise operations into contraction during evaluation. * Performance optimizations of other Tensor operator * Speedups from improved vectorization, block evaluation, and multi-threading for most operators. * Significant speedup to broadcasting. * Reduction of index computation overhead, e.g. using fast divisors in TensorGenerator, squeezing dimensions in TensorPadding. * Complete rewrite of the block (tiling) evaluation framework for tensor expressions lead to significant speedups and reduced number of memory allocations. * Added new API for asynchronous evaluation of tensor expressions. * Misc. minor behavior changes & fixes: * Fix const correctness for TensorMap. * Modify tensor argmin/argmax to always return first occurrence. * More numerically stable tree reduction. * Improve randomness of the tensor random generator. * Update the padding computation for `PADDING_SAME` to be consistent with TensorFlow. * Support static dimensions (aka IndexList) in resizing/reshape/broadcast. * Improved accuracy of Tensor FFT. ### Changes to sparse iterative solvers * Added new IDRS iterative linear solver. ### Other relevant changes * Eigen now provides an option to test with an external BLAS library See the [announcement](https://www.eigen.tuxfamily.org/index.php?title=3.4) for more details. ## [3.3.9] Released on December 4, 2020. Changes since 3.3.8: * Commit 4e5385c90: Introduce rendering Doxygen math formulas with MathJax and the option `EIGEN_DOC_USE_MATHJAX` to control this. * #1746: Removed implementation of standard copy-constructor and standard copy-assign-operator from PermutationMatrix and Transpositions to allow malloc-less `std::move`. * #2036: Make sure the find_standard_math_library_test_program compiles and doesn't optimize away functions we try to test for. * #2046: Rename test/array.cpp to test/array_cwise.cpp to fix an issue with the C++ standard library header "array" * #2040: Fix an issue in test/ctorleak that occured when disabling exceptions. * #2011: Remove error counting in OpenMP parallel section in Eigen's GEMM parallelizing logic. * #2012: Define coeff-wise binary array operators for base class to fix an issue when using Eigen with C++20 * Commit bfdd4a990: Fix an issue with Intel® MKL PARDISO support. ## [3.3.8] Released on October 5, 2020. Changes since 3.3.7: * General bug fixes * #1995: Fix a failure in the GEBP kernel when using small L1 cache sizes, OpenMP and FMA. * #1990: Make CMake accept installation paths relative to `CMAKE_INSTALL_PREFIX`. * #1974: Fix issue when reserving an empty sparse matrix * #1823: Fix incorrect use of `std::abs` * #1788: Fix rule-of-three violations inside the stable modules. This fixes deprecated-copy warnings when compiling with GCC>=9 Also protect some additional Base-constructors from getting called by user code code (#1587) * #1796: Make matrix squareroot usable for Map and Ref types * #1281: Fix AutoDiffScalar's make_coherent for nested expression of constant ADs. * #1761: Fall back `is_integral` to `std::is_integral` in c++11 and fix `internal::is_integral` with MSVC 2013 and older. * #1741: Fix `self_adjoint*matrix`, `triangular*matrix`, and `triangular^1*matrix` with a destination having a non-trivial inner-stride * #1741: Fix SelfAdjointView::rankUpdate and product to triangular part for destination with non-trivial inner stride * #1741: Fix `C.noalias() = A*C;` with `C.innerStride()!=1` * #1695: Fix a numerical robustness issue in BDCSVD * #1692: Enable enum as sizes of Matrix and Array * #1689: Fix used-but-marked-unused warning * #1679: Avoid possible division by 0 in complex-schur * #1676: Fix C++17 template deduction in DenseBase * #1669: Fix PartialPivLU/inverse with zero-sized matrices. * #1557: Fix RealSchur and EigenSolver for matrices with only zeros on the diagonal. * Performance related fixes * #1562: Optimize evaluation of small products of the form s*A*B by rewriting them as: s*(A.lazyProduct(B)) to save a costly temporary. Measured speedup from 2x to 5x... * Commit 165db26dc and 8ee2e10af: Fix performance issue with SimplicialLDLT for complexes coefficients * Misc commits * Commit 5f1082d0b: Fix `QuaternionBase::cast` for quaternion map and wrapper. * Commit a153dbae9: Fix case issue with Lapack unit tests. * Commit 3d7e2a1f3: Fix possible conflict with an externally defined "real" type when using gcc-5. * Commit 1760432f6: Provide `numext::[u]int{32,64}_t`. * Commit 3d18879fc: Initialize isometric transforms like affine transforms. * Commit 160c0a340: Change typedefs from private to protected to fix MSVC compilation. * Commit 3cf273591: Fix compilation of FFTW unit test. * Commit 6abc9e537: Fix compilation of BLAS backend and frontend. * Commit 47e2f8a42: Fix real/imag namespace conflict. * Commit 71d0402e3: Avoid throwing in destructors. * Commit 0dd9643ad: Fix precision issue in `SelfAdjointEigenSolver.h` * Commit 6ed74ac97: Make `digits10()` return an integer. * Commit 841d844f9: Use pade for matrix exponential also for complex values. * Commit 4387298e8: Cast Index to RealScalar in SVDBase to fix an issue when RealScalar is not implicitly convertible to Index. * Commit fe8cd812b: Provide `EIGEN_HAS_C99_MATH` when using MSVC. * Commit 7c4208450: Various fixes in polynomial solver and its unit tests. * Commit e777674a8 and 4415d4e2d: Extend polynomial solver unit tests to complexes. * Commit 222ce4b49: Automatically switch between EigenSolver and ComplexEigenSolver, and fix a few Real versus Scalar issues. * Commit 7b93328ba: Enable construction of `Ref` from a runtime vector. * Commit c28ba89fe: Fix a problem of old gcc versions having problems with recursive #pragma GCC diagnostic push/pop. * Commit 210d510a9: Fix compilation with expression template scalar type. * Commit efd72cddc: Backport AVX512 implementation to 3.3. * Commit 5e484fa11: Fix StlDeque compilation issue with GCC 10. * Commit a796be81a: Avoid false-positive test results in non-linear optimization tests * Commit 9f202c6f1: Fix undefined behaviour caused by uncaught exceptions in OMP section of parallel GEBP kernel. * Commit 4707c3aa8: Fix a bug with half-precision floats on GPUs. * Fixed warnings * Commit 14db78c53: Fix some maybe-uninitialized warnings in AmbiVector.h and test bdcsvd. * Commit f1b1f13d3: silent cmake warnings in Lapack CMakeLists.txt * Commit 8fb28db12: Rename variable which shadows class name in Polynomials module. * Commit f1c12d8ff: Workaround gcc's `alloc-size-larger-than=` warning in DenseStorage.h * Commit 6870a39fe: Hide some unused variable warnings in g++8.1 in Tensor contraction mapper. * Commit bb9981e24: Fix gcc 8.1 warning: "maybe use uninitialized" in std tests * Commit eea99eb4e: Fix always true warning with gcc 4.7in test numext. * Commit 65a6d4151: Fix nonnull-compare warning in test geo_alignedbox. * Commit 74a0c08d7: Disable ignoring attributes warning in vectorization logic test. * Commit 6c4d57dc9: Fix a gcc7 warning about bool * bool in abs2 default implementation. * Commit 89a86ed42: Fix a warning in SparseSelfAdjointView about a branch statement always evaluation to false. ## [3.3.8-rc1] Released on September 14, 2020. Changes since 3.3.7: * General bug fixes * #1974: Fix issue when reserving an empty sparse matrix * #1823: Fix incorrect use of `std::abs` * #1788: Fix rule-of-three violations inside the stable modules. This fixes deprecated-copy warnings when compiling with GCC>=9 Also protect some additional Base-constructors from getting called by user code code (#1587) * #1796: Make matrix squareroot usable for Map and Ref types * #1281: Fix AutoDiffScalar's `make_coherent` for nested expression of constant ADs. * #1761: Fall back `is_integral` to `std::is_integral` in c++11 and fix `internal::is_integral` with MSVC 2013 and older. * #1741: Fix `self_adjoint*matrix`, `triangular*matrix`, and `triangular^1*matrix` with a destination having a non-trivial inner-stride * #1741: Fix SelfAdjointView::rankUpdate and product to triangular part for destination with non-trivial inner stride * #1741: Fix `C.noalias() = A*C;` with `C.innerStride()!=1` * #1695: Fix a numerical robustness issue in BDCSVD * #1692: Enable enum as sizes of Matrix and Array * #1689: Fix used-but-marked-unused warning * #1679: Avoid possible division by 0 in complex-schur * #1676: Fix C++17 template deduction in DenseBase * #1669: Fix PartialPivLU/inverse with zero-sized matrices. * #1557: Fix RealSchur and EigenSolver for matrices with only zeros on the diagonal. * Performance related fixes * #1562: Optimize evaluation of small products of the form s*A*B by rewriting them as: s*(A.lazyProduct(B)) to save a costly temporary. Measured speedup from 2x to 5x... * Commit 165db26dc and 8ee2e10af: Fix performance issue with SimplicialLDLT for complexes coefficients * Misc commits * Commit 5f1082d0b: Fix `QuaternionBase::cast` for quaternion map and wrapper. * Commit a153dbae9: Fix case issue with Lapack unit tests. * Commit 3d7e2a1f3: Fix possible conflict with an externally defined "real" type when using gcc-5. * Commit 1760432f6: Provide `numext::[u]int{32,64}_t`. * Commit 3d18879fc: Initialize isometric transforms like affine transforms. * Commit 160c0a340: Change typedefs from private to protected to fix MSVC compilation. * Commit 3cf273591: Fix compilation of FFTW unit test. * Commit 6abc9e537: Fix compilation of BLAS backend and frontend. * Commit 47e2f8a42: Fix real/imag namespace conflict. * Commit 71d0402e3: Avoid throwing in destructors. * Commit 0dd9643ad: Fix precision issue in SelfAdjointEigenSolver.h * Commit 6ed74ac97: Make digits10() return an integer. * Commit 841d844f9: Use pade for matrix exponential also for complex values. * Commit 4387298e8: Cast Index to RealScalar in SVDBase to fix an issue when RealScalar is not implicitly convertible to Index. * Commit fe8cd812b: Provide `EIGEN_HAS_C99_MATH` when using MSVC. * Commit 7c4208450: Various fixes in polynomial solver and its unit tests. * Commit e777674a8 and 4415d4e2d: Extend polynomial solver unit tests to complexes. * Commit 222ce4b49: Automatically switch between EigenSolver and ComplexEigenSolver, and fix a few Real versus Scalar issues. * Commit 5110d803e: Change license from LGPL to MPL2 with agreement from David Harmon. (grafted from 2df4f0024666a9085fe47f14e2290bd61676dbbd ) * Commit 7b93328ba: Enable construction of `Ref` from a runtime vector. * Commit c28ba89fe: Fix a problem of old gcc versions having problems with recursive #pragma GCC diagnostic push/pop. * Commit 210d510a9: Fix compilation with expression template scalar type. * Fixed warnings * Commit 14db78c53: Fix some maybe-uninitialized warnings in AmbiVector.h and test bdcsvd. * Commit f1b1f13d3: silent cmake warnings in Lapack CMakeLists.txt * Commit 8fb28db12: Rename variable which shadows class name in Polynomials module. * Commit f1c12d8ff: Workaround gcc's `alloc-size-larger-than=` warning in DenseStorage.h * Commit 6870a39fe: Hide some unused variable warnings in g++8.1 in Tensor contraction mapper. * Commit bb9981e24: Fix gcc 8.1 warning: "maybe use uninitialized" in std tests * Commit eea99eb4e: Fix always true warning with gcc 4.7in test `numext`. * Commit 65a6d4151: Fix nonnull-compare warning in test `geo_alignedbox`. * Commit 74a0c08d7: Disable ignoring attributes warning in vectorization logic test. * Commit 6c4d57dc9: Fix a gcc7 warning about bool * bool in abs2 default implementation. * Commit efd72cddc: Backport AVX512 implementation to 3.3. * Commit 5e484fa11: Fix StlDeque compilation issue with GCC 10. * Commit 89a86ed42: Fix a warning in SparseSelfAdjointView about a branch statement always evaluation to false. * Commit dd6de618: Fix a bug with half-precision floats on GPUs. ## [3.3.7] Released on December 11, 2018. Changes since 3.3.6: * #1643: Fix compilation with GCC>=6 and compiler optimization turned off. ## [3.3.6] Released on December 10, 2018. Changes since 3.3.5: * #1617: Fix triangular solve crashing for empty matrix. * #785: Make dense Cholesky decomposition work for empty matrices. * #1634: Remove double copy in move-ctor of non movable Matrix/Array. * Changeset 588e1eb34eff: Workaround weird MSVC bug. * #1637 Workaround performance regression in matrix products with gcc>=6 and clang>=6.0. * Changeset bf0f100339c1: Fix some implicit 0 to Scalar conversions. * #1605: Workaround ABI issue with vector types (aka `__m128`) versus scalar types (aka float). * Changeset d1421c479baa: Fix for gcc<4.6 regarding usage of #pragma GCC diagnostic push/pop. * Changeset c20b83b9d736: Fix conjugate-gradient for right-hand-sides with a very small magnitude. * Changeset 281a877a3bf7: Fix product of empty arrays (returned 0 instead of 1). * #1590: Fix collision with some system headers defining the macro FP32. * #1584: Fix possible undefined behavior in random generation. * Changeset d632d18db8ca: Fix fallback to BLAS for rankUpdate. * Fixes for NVCC 9. * Fix matrix-market IO. * Various fixes in the doc. * Various minor warning fixes/workarounds. ## [3.3.5] Released on July 23, 2018. Changes since 3.3.4: * General bug fixes: * Fix GeneralizedEigenSolver when requesting for eigenvalues only (0d15855abb30) * #1560 fix product with a 1x1 diagonal matrix (90d7654f4a59) * #1543: fix linear indexing in generic block evaluation * Fix compilation of product with inverse transpositions (e.g., `mat * Transpositions().inverse()`) (14a13748d761) * #1509: fix `computeInverseWithCheck` for complexes (8be258ef0b6d) * #1521: avoid signalling `NaN` in hypot and make it std::complex<> friendly (a9c06b854991). * #1517: fix triangular product with unit diagonal and nested scaling factor: `(s*A).triangularView()*B` (a546d43bdd4f) * Fix compilation of stableNorm for some odd expressions as input (499e982b9281) * #1485: fix linking issue of non template functions (ae28c2aaeeda) * Fix overflow issues in BDCSVD (92060f82e1de) * #1468: add missing `std::` to `memcpy` (4565282592ae) * #1453: fix Map with non-default inner-stride but no outer-stride (af00212cf3a4) * Fix mixing types in sparse matrix products (7e5fcd0008bd) * #1544: Generate correct Q matrix in complex case (c0c410b508a1) * #1461: fix compilation of `Map::x()` (69652a06967d) * Backends: * Fix MKL backend for symmetric eigenvalues on row-major matrices (4726d6a24f69) * #1527: fix support for MKL's VML (972424860545) * Fix incorrect ldvt in LAPACKE call from JacobiSVD (88c4604601b9) * Fix support for MKL's BLAS when using `MKL_DIRECT_CALL` (205731b87e19, b88c70c6ced7, 46e2367262e1) * Use MKL's lapacke.h header when using MKL (19bc9df6b726) * Diagnostics: * #1516: add assertion for out-of-range diagonal index in `MatrixBase::diagonal(i)` (783d38b3c78c) * Add static assertion for fixed sizes `Ref<>` (e1203d5ceb8e) * Add static assertion on selfadjoint-view's UpLo parameter. (b84db94c677e, 0ffe8a819801) * #1479: fix failure detection in LDLT (67719139abc3) * Compiler support: * #1555: compilation fix with XLC * Workaround MSVC 2013 ambiguous calls (1c7b59b0b5f4) * Adds missing `EIGEN_STRONG_INLINE` to help MSVC properly inlining small vector calculations (1ba3f10b91f2) * Several minor warning fixes: 3c87fc0f1042, ad6bcf0e8efc, "used uninitialized" (20efc44c5500), Wint-in-bool-context (131da2cbc695, b4f969795d1b) * #1428: make NEON vectorization compilable by MSVC. (* 3d1b3dbe5927, 4e1b7350182a) * Fix compilation and SSE support with PGI compiler (faabf000855d 90d33b09040f) * #1555: compilation fix with XLC (23eb37691f14) * #1520: workaround some `-Wfloat-equal` warnings by calling `std::equal_to` (7d9a9456ed7c) * Make the TensorStorage class compile with clang 3.9 (eff7001e1f0a) * Misc: some old compiler fixes (493691b29be1) * Fix MSVC warning C4290: C++ exception specification ignored except to indicate a function is not `__declspec(nothrow)` (524918622506) * Architecture support: * Several AVX512 fixes for `log`, `sqrt`, `rsqrt`, non `AVX512ER` CPUs, `apply_rotation_in_the_plane` b64275e912ba cab3d626a59e 7ce234652ab9, d89b9a754371. * AltiVec fixes: 9450038e380d * NEON fixes: const-cast (e8a69835ccda), compilation of Jacobi rotations (c06cfd545b15,#1436). * Changeset d0658cc9d4a2: Define `pcast<>` for SSE types even when AVX is enabled. (otherwise float are silently reinterpreted as int instead of being converted) * #1494: makes `pmin`/`pmax` behave on Altivec/VSX as on x86 regarding NaNs (d0af83f82b19) * Documentation: * Update manual pages regarding BDCSVD (#1538) * Add aliasing in common pitfaffs (2a5a8408fdc5) * Update `aligned_allocator` (21e03aef9f2b) * #1456: add perf recommendation for LLT and storage format (c8c154ebf130, 9aef1e23dbe0) * #1455: Cholesky module depends on Jacobi for rank-updates (2e6e26b851a8) * #1458: fix documentation of LLT and LDLT `info()` method (2a4cf4f473dd) * Warn about constness in `LLT::solveInPlace` (518f97b69bdf) * Fix lazyness of `operator*` with CUDA (c4dbb556bd36) * #336: improve doc for `PlainObjectBase::Map` (13dc446545fe) * Other general improvements: * Enable linear indexing in generic block evaluation (31537598bf83, 5967bc3c2cdb, #1543). * Fix packet and alignment propagation logic of `Block` expressions. In particular, `(A+B).col(j)` now preserve vectorisation. (b323cc9c2c7f) * Several fixes regarding custom scalar type support: hypot (f8d6c791791d), boost-multiprec (acb8ef9b2478), literal casts (6bbd97f17534, 39f65d65894f), * LLT: avoid making a copy when decomposing in place (2f7e28920f4e), const the arg to `solveInPlace()` to allow passing `.transpose()`, `.block()`, etc. (c31c0090e998). * Add possibility to overwrite `EIGEN_STRONG_INLINE` (7094bbdf3f4d) * #1528: use `numeric_limits::min()` instead of `1/highest()` that might underflow (dd823c64ade7) * #1532: disable `stl::*_negate` in C++17 (they are deprecated) (88e9452099d5) * Add C++11 `max_digits10` for half (faf74dde8ed1) * Make sparse QR result sizes consistent with dense QR (4638bc4d0f96) * Unsupported/unit-tests/cmake/unvisible internals/etc. * #1484: restore deleted line for 128 bits long doubles, and improve dispatching logic. (dffc0f957f19) * #1462: remove all occurences of the deprecated `__CUDACC_VER__` macro by introducing `EIGEN_CUDACC_VER` (a201b8438d36) * Changeset 2722aa8eb93f: Fix oversharding bug in parallelFor. * Changeset ea1db80eab46: commit 45e9c9996da790b55ed9c4b0dfeae49492ac5c46 (HEAD -> memory_fix) * Changeset 350957be012c: Fix int versus Index * Changeset 424038431015: fix linking issue * Changeset 3f938790b7e0: Fix short vs long * Changeset ba14974d054a: Fix cmake scripts with no fortran compiler * Changeset 2ac088501976: add cmake-option to enable/disable creation of tests * Changeset 56996c54158b: Use col method for column-major matrix * Changeset 762373ca9793: #1449: fix `redux_3` unit test * Changeset eda96fd2fa30: Fix uninitialized output argument. * Changeset 75a12dff8ca4: Handle min/max/inf/etc issue in `cuda_fp16.h` directly in `test/main.h` * Changeset 568614bf79b8: Add tests for sparseQR results (value and size) covering bugs 1522 and 1544 * Changeset 12c9ece47d14: `SelfAdjointView<...,Mode>` causes a static assert since commit c73a77e47db8 * Changeset 899fd2ef704f: weird compilation issue in `mapped_matrix.cpp` ## [3.3.4] Released on June 15, 2017. Changes since 3.3.3: * General: * Improve speed of Jacobi rotation when mixing complex and real types. * #1405: enable StrictlyLower/StrictlyUpper triangularView as the destination of matrix*matrix products. * UmfPack support: enable changes in the control settings and add report functions. * #1423: fix LSCG's Jacobi preconditioner for row-major matrices. * #1424: fix compilation issue with abs and unsigned integers as scalar type. * #1410: fix lvalue propagation of Array/Matrix-Wrapper with a const nested expression. * #1403: fix several implicit scalar type conversion making SVD decompositions compatible with ceres::Jet. * Fix some real-to-scalar-to-real useless conversions in `ColPivHouseholderQR`. * Regressions: * Fix `dense * sparse_selfadjoint_view` product. * #1417: make LinSpace compatible with std::complex. * #1400: fix `stableNorm` alignment issue with `EIGEN_DONT_ALIGN_STATICALLY`. * #1411: fix alignment issue in `Quaternion`. * Fix compilation of operations between nested Arrays. * #1435: fix aliasing issue in expressions like: `A = C - B*A`. * Others: * Fix compilation with gcc 4.3 and ARM NEON. * Fix prefetches on ARM64 and ARM32. * Fix out-of-bounds check in COLAMD. * Few minor fixes regarding nvcc/CUDA support, including #1396. * Improve cmake scripts for Pastix and BLAS detection. * #1401: fix compilation of `cond ? x : -x` with `x` an `AutoDiffScalar` * Fix compilation of matrix log with Map as input. * Add specializations of `std::numeric_limits` for `Eigen::half` and and `AutoDiffScalar` * Fix compilation of streaming nested Array, i.e., `std::cout << Array>` ## [3.3.3] Released on February 21, 2017. Changes since 3.3.2: * General: * Improve multi-threading heuristic for matrix products with a small number of columns. * #1395: fix compilation of JacobiSVD for vectors type. * Fix pruning in `(sparse*sparse).pruned()` when the result is nearly dense. * #1382: move using `std::size_t`/`ptrdiff_t` to Eigen's namespace. * Fix compilation and inlining when using clang-cl with visual studio. * #1392: fix `#include ` with mpl2-only. * Regressions: * #1379: fix compilation in `sparse*diagonal*dense` with OpenMP. * #1373: add missing assertion on size mismatch with compound assignment operators (e.g., mat += mat.col(j)) * #1375: fix cmake installation with cmake 2.8. * #1383: fix LinSpaced with integers for `LinPspaced(n,0,n-1)` with `n==0` or the `high(sparse*sparse)`. * Others: * Fix ARM NEON wrapper for 16 byte systems. * #1391: include IO.h before DenseBase to enable its usage in DenseBase plugins. * #1389: fix std containers support with MSVC and AVX. * #1380: fix matrix exponential with `Map<>`. * #1369: fix type mismatch warning with OpenMP. * Fix usage of `size_t` instead of Index in sefl-adjoint `matrix * vector` * #1378: fix doc (`DiagonalIndex` vs `Diagonal`). ## [3.3.2] Released on January 18, 2017. Changes since 3.3.1: * General: * Add `transpose`, `adjoint`, `conjugate` methods to `SelfAdjointView` (useful to write generic code) * Make sure that `HyperPlane::transform` maintains a unit normal vector in the Affine case. * Several documentation improvements, including: several doxygen workarounds, #1336, #1370, StorageIndex, selfadjointView, sparseView(), sparse triangular solve, AsciiQuickReference.txt, ... * Regressions: * #1358: fix compilation of `sparse += sparse.selfadjointView()`. * #1359: fix compilation of `sparse /=scalar`, `sparse *=scalar`, and `col_major_sparse.row() *= scalar`. * #1361: fix compilation of mat=perm.inverse() * Some fixes in sparse coeff-wise binary operations: add missing `.outer()` member to iterators, and properly report storage order. * Fix aliasing issue in code as `A.triangularView() = B*A.sefladjointView()*B.adjoint()` * Performance: * Improve code generation for `mat*vec` on some compilers. * Optimize horizontal adds in SSE3 and AVX. * Speed up row-major TRSM (triangular solve with a matrix as right-hand-side) by reverting `vec/y` to `vec*(1/y)`. The rationale is: * div is extremely costly * this is consistent with the column-major case * this is consistent with all other BLAS implementations * Remove one temporary in `SparseLU::solve()` * Others: * Fix BLAS backend for symmetric rank K updates. * #1360: fix `-0` vs `+0` issue with Altivec * #1363: fix mingw's ABI issue * #1367: fix compilation with gcc 4.1. * Fix ABI issue with AVX and old gcc versions. * Fix some warnings with ICC, Power8, etc. * Fix compilation with MSVC 2017 ## [3.3.1] Released on December 06, 2016. Changes since 3.3.0: * #426: add operators `&&` and `||` to dense and sparse matrices (only dense arrays were supported) * #1319: add support for CMake's imported targets. * #1343: fix compilation regression in `array = matrix_product` and `mat+=selfadjoint_view` * Fix regression in assignment of sparse block to sparse block. * Fix a memory leak in `Ref` and `Ref`. * #1351: fix compilation of random with old compilers. * Fix a performance regression in (mat*mat)*vec for which mat*mat was evaluated multiple times. * Fix a regression in `SparseMatrix::ReverseInnerIterator` * Fix performance issue of products for dynamic size matrices with fixed max size. * implement `float`/`std::complex` for ZVector * Some fixes for expression-template scalar-types * #1356: fix undefined behavior with nullptr. * Workaround some compilation errors with MSVC and MSVC/clr * #1348: document `EIGEN_MAX_ALIGN_BYTES` and `EIGEN_MAX_STATIC_ALIGN_BYTES`, and reflect in the doc that `EIGEN_DONT_ALIGN*` are deprecated. * Bugs #1346,#1347: make Eigen's installation relocatable. * Fix some harmless compilation warnings. ## [3.3] Released on November 10, 2016 For a comprehensive list of change since the 3.2 series, see this [page](https://www.eigen.tuxfamily.org/index.php?title=3.3). Main changes since 3.3-rc2: * Fix regression in printing sparse expressions. * Fix sparse solvers when using a SparseVector as the result and/or right-hand-side. ## [3.3-rc2] Released on November 04, 2016 For a comprehensive list of change since the 3.2 series, see this [page](https://www.eigen.tuxfamily.org/index.php?title=3.3). Main changes since 3.3-rc1: * Core module * Add supports for AVX512 SIMD instruction set. * Bugs #698 and #1004: Improve numerical robustness of LinSpaced methods for both real and integer scalar types ([details](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1DenseBase.html#aaef589c1dbd7fad93f97bd3fa1b1e768)). * Fix a regression in `X = (X*X.transpose())/scalar` with `X` rectangular (`X` was resized before the evaluation). * #1311: Fix alignment logic in some cases of `(scalar*small).lazyProduct(small)` * #1317: fix a performance regression from 3.2 with clang and some nested block expressions. * #1308: fix compilation of some small products involving nullary-expressions. * #1333: Fix a regression with `mat.array().sum()` * #1328: Fix a compilation issue with old compilers introduced in 3.3-rc1. * #1325: Fix compilation on NEON with clang * Properly handle negative inputs in vectorized sqrt. * Improve cost-model to determine the ideal number of threads in matrix-matrix products. * Geometry module * #1304: Fix `Projective * scaling` and `Projective *= scaling`. * #1310: Workaround a compilation regression from 3.2 regarding triangular * homogeneous * #1312: Quaternion to AxisAngle conversion now ensures the angle will be in the range `[0,pi]`. This also increases accuracy when `q_w` is negative. * Tensor module * Add support for OpenCL. * Improved random number generation. * Other * #1330: SuiteSparse, explicitly handle the fact that Cholmod does not support single precision float numbers. * SuiteSparse, fix SPQR for rectangular matrices * Fix compilation of `qr.inverse()` for column and full pivoting variants ## [3.2.10] Released on October 04, 2016 Changes since 3.2.9: Main fixes and improvements: * #1272: Core module, improve comma-initializer in handling empty matrices. * #1276: Core module, remove all references to `std::binder*` when C++11 is enabled (those are deprecated). * #1304: Geometry module, fix `Projective * scaling` and `Projective *= scaling`. * #1300: Sparse module, compilation fix for some block expression and SPQR support. * Sparse module, fix support for row (resp. column) of a column-major (resp. row-major) sparse matrix. * LU module, fix 4x4 matrix inversion for non-linear destinations. * Core module, a few fixes regarding custom complex types. * #1275: backported improved random generator from 3.3 * Workaround MSVC 2013 compilation issue in Reverse * Fix UmfPackLU constructor for expressions. * #1273: fix shortcoming in eigen_assert macro * #1249: disable the use of `__builtin_prefetch` for compilers other than GCC, clang, and ICC. * #1265: fix doc of QR decompositions ## [3.3-rc1] Released on September 22, 2016 For a comprehensive list of change since the 3.2 series, see this [page](https://www.eigen.tuxfamily.org/index.php?title=3.3). Main changes since 3.3-beta2: * New features and improvements: * #645: implement eigenvector computation in GeneralizedEigenSolver * #1271: add a `SparseMatrix::coeffs()` method returning a linear view of the non-zeros (for compressed mode only). * #1286: Improve support for custom nullary functors: now the functor only has to expose one relevant operator among `f()`, `f(i)`, `f(i,j)`. * #1272: improve comma-initializer in handling empty matrices. * #1268: detect failure in LDLT and report them through info() * Add support for scalar factor in sparse-selfadjoint `*` dense products, and enable `+=`/`-=` assignment for such products. * Remove temporaries in product expressions matching `d?=a-b*c` by rewriting them as `d?=a; d?=b*c;` * Vectorization improvements for some small product cases. * Doc: * #1265: fix outdated doc in QR facto * #828: improve documentation of sparse block methods, and sparse unary methods. * Improve documentation regarding nullary functors, and add an example demonstrating the use of nullary expression to perform fancy matrix manipulations. * Doc: explain how to use Accelerate as a LAPACK backend. * Bug fixes and internal changes: * Numerous fixes regarding support for custom complex types. * #1273: fix shortcoming in `eigen_assert` macro * #1278: code formatting * #1270: by-pass hand written `pmadd` with recent clang versions. * #1282: fix implicit double to float conversion warning * #1167: simplify installation of header files using cmake's `install(DIRECTORY ...)` command * #1283: fix products involving an uncommon `vector.block(..)` expressions. * #1285: fix a minor regression in LU factorization. * JacobiSVD now consider any denormal number as zero. * Numerous fixes regarding support for CUDA/NVCC (including bugs #1266) * Fix an alignment issue in gemv, symv, and trmv for statically allocated temporaries. * Fix 4x4 matrix inversion for non-linear destinations. * Numerous improvements and fixes in half precision scalar type. * Fix vectorization logic for coeff-based product for some corner cases * Bugs #1260, #1261, #1264: several fixes in AutoDiffScalar. ## [3.3-beta2] Released on July 26, 2016 For a comprehensive list of change since the 3.2 series, see this [page](https://www.eigen.tuxfamily.org/index.php?title=3.3). Main changes since 3.3-beta1: * Dense features: * #707: Add support for [inplace](http://eigen.tuxfamily.org/dox-devel/group__InplaceDecomposition.html) dense decompositions. * #977: normalize(d) left the input unchanged if its norm is 0 or too close to 0. * #977: add stableNormalize[d] methods: they are analogues to normalize[d] but with carefull handling of under/over-flow. * #279: Implement generic scalar*expr and expr*scalar operators. This is especially useful for custom scalar types, e.g., to enable `float*expr` without conversion. * New unsupported/Eigen/SpecialFunctions module providing the following coefficient-wise math functions: erf, erfc, lgamma, digamma, polygamma, igamma, igammac, zeta, betainc. * Add fast reciprocal condition estimators in dense LU and Cholesky factorizations. * #1230: add support for `SelfadjointView::triangularView()` and `diagonal()` * #823: add `Quaternion::UnitRandom()` method. * Add exclusive or operator for bool arrays. * Relax dependency on MKL for `EIGEN_USE_BLAS` and `EIGEN_USE_LAPACKE`: any BLAS and LAPACK libraries can now be used as backend (see [doc](http://eigen.tuxfamily.org/dox-devel/TopicUsingBlasLapack.html)). * Add static assertion to `x()`, `y()`, `z()`, `w()` accessors * #51: avoid dynamic memory allocation in fixed-size rank-updates, matrix products evaluated within a triangular part, and selfadjoint times matrix products. * #696: enable zero-sized block at compile-time by relaxing the respective assertion * #779: in `Map`, allows non aligned buffers for buffers smaller than the requested alignment. * Add a complete orthogonal decomposition class: [CompleteOrthogonalDecomposition](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1CompleteOrthogonalDecomposition.html) * Improve robustness of JacoviSVD with complexes (underflow, noise amplification in complex to real conversion, compare off-diagonal entries to the current biggest diagonal entry instead of the global biggest, null inputs). * Change Eigen's ColPivHouseholderQR to use a numerically stable norm downdate formula (changeset 9da6c621d055) * #1214: consider denormals as zero in D&C SVD. This also workaround infinite binary search when compiling with ICC's unsafe optimizations. * Add log1p for arrays. * #1193: now `lpNorm` supports empty inputs. * #1151: remove useless critical section in matrix product * Add missing non-const reverse method in `VectorwiseOp` (e.g., this enables `A.rowwise().reverse() = ...`) * Update RealQZ to reduce 2x2 diagonal block of T corresponding to non reduced diagonal block of S to positive diagonal form. * Sparse features: * #632: add support for "dense +/- sparse" operations. The current implementation is based on SparseView to make the dense subexpression compatible with the sparse one. * #1095: add Cholmod*::logDeterminant/determinant functions. * Add `SparseVector::conservativeResize()` method * #946: generalize `Cholmod::solve` to handle any rhs expressions. * #1150: make IncompleteCholesky more robust by iteratively increase the shift until the factorization succeed (with at most 10 attempts) * #557: make InnerIterator of sparse storage types more versatile by adding default-ctor, copy-ctor/assignment. * #694: document that `SparseQR::matrixR` is not sorted. * Block expressions now expose all the information defining the block. * Fix GMRES returned error. * #1119: add support for SuperLU 5 * Performance improvements: * #256: enable vectorization with unaligned loads/stores. This concerns all architectures and all sizes. This new behavior can be disabled by defining `EIGEN_UNALIGNED_VECTORIZE=0` * Add support for s390x(zEC13) ZVECTOR instruction set. * Optimize mixing of real with complex matrices by avoiding a conversion from real to complex when the real types do not match exactly. (see bccae23d7018) * Speedup square roots in performance critical methods such as norm, normalize(d). * #1154: use dynamic scheduling for spmv products. * #667, #1181: improve perf with MSVC and ICC through `FORCE_INLINE` * Improve heuristics for switching between coeff-based and general matrix product implementation at compile-time. * Add vectorization of tanh for float (SSE/AVX) * Improve cost estimates of numerous functors. * Numerous improvements regarding half-packet vectorization: coeff-based products (e.g., `Matrix4f*Vector4f` is now vectorized again when using AVX), reductions, linear vs inner traversals. * Fix performance regression: with AVX, unaligned stores were emitted instead of aligned ones for fixed size assignment. * #1201: optimize `affine*vector` products. * #1191: prevent Clang/ARM from rewriting VMLA into VMUL+VADD. * Small speed-up in `Quaternion::slerp`. * #1201: improve code generation of affine*vec with MSVC * Doc: * Add [documentation and exemple](http://eigen.tuxfamily.org/dox-devel/group__MatrixfreeSolverExample.html) for matrix-free solving. * A new documentation [page](http://eigen.tuxfamily.org/dox-devel/group__CoeffwiseMathFunctions.html) summarizing coefficient-wise math functions. * #1144: clarify the doc about aliasing in case of resizing and matrix product. * A new documentation [page](http://eigen.tuxfamily.org/dox-devel/group__DenseDecompositionBenchmark.html) summarizing the true performance of Eigen's dense decomposition algorithms. * Misc improvements: * Allow one generic scalar argument for all binary operators/functions. * Add a `EIGEN_MAX_CPP_VER` option to limit the C++ version to be used, as well as [fine grained options](http://eigen.tuxfamily.org/dox-devel/TopicPreprocessorDirectives.html#title1) to control individual language features. * A new [ScalarBinaryOpTraits](http://eigen.tuxfamily.org/dox-devel/structEigen_1_1ScalarBinaryOpTraits.html) class allowing to control how different scalar types are mixed. * `NumTraits` now exposes a `digits10` function making `internal::significant_decimals_impl` deprecated. * Countless improvements and fixes in Tensors module. * #1156: fix several function declarations whose arguments were passed by value instead of being passed by reference * #1164: fix `std::list` and `std::deque` specializations such that our aligned allocator is automatically activated only when the user did not specified an allocator (or specified the default std::allocator). * #795: mention allocate_shared as a candidate for aligned_allocator. * #1170: skip calls to memcpy/memmove for empty inputs. * #1203: by-pass large stack-allocation in stableNorm if `EIGEN_STACK_ALLOCATION_LIMIT` is too small * Improve constness of blas level-2/3 interface. * Implement stricter argument checking for SYRK and SY2K * Countless improvements in the documentations. * Internal: Remove `posix_memalign`, `_mm_malloc`, and `_aligned_malloc` special paths. * Internal: Remove custom unaligned loads for SSE * Internal: introduce `[U]IntPtr` types to be used for casting pointers to integers. * Internal: `NumTraits` now exposes `infinity()` * Internal: `EvalBeforeNestingBit` is now deprecated. * #1213: workaround gcc linking issue with anonymous enums. * #1242: fix comma initializer with empty matrices. * #725: make move ctor/assignment noexcept * Add minimal support for `Array` * Improve support for custom scalar types bases on expression template (e.g., `boost::multiprecision::number<>` type). All dense decompositions are successfully tested. * Most visible fixes: * #1144: fix regression in `x=y+A*x` (aliasing issue) * #1140: fix usage of `_mm256_set_m128` and `_mm256_setr_m128` in AVX support * #1141: fix some missing initializations in CholmodSupport * #1143: workaround gcc bug #10200 * #1145, #1147, #1148, #1149: numerous fixes in PastixSupport * #1153: don't rely on `__GXX_EXPERIMENTAL_CXX0X__` to detect C++11 support. * #1152: fix data race in static initialization of blas routines. * fix some buffer overflow in product block size computation. * #96, #1006: fix by value argument in result_of * #178: clean several `const_cast`. * Fix compilation in `ceil()` function. * #698: fix linspaced for integer types. * #1161: fix division by zero for huge scalar types in cache block size computation. * #774: fix a numerical issue in Umeyama algorithm that produced unwanted reflections. * #901: fix triangular-view with unit diagonal of sparse rectangular matrices. * #1166: fix shortcoming in gemv when the destination is not a vector at compile-time. * #1172: make `SparseMatrix::valuePtr` and `innerIndexPtr` properly return null for empty matrices * #537: fix a compilation issue in Quaternion with Apples's compiler * #1186: fix usage of `vreinterpretq_u64_f64` (NEON) * #1190: fix usage of `__ARM_FEATURE_FMA` on Clang/ARM * #1189: fix pow/atan2 compilation for `AutoDiffScalar` * Fix detection of same input-output when applied permutations, or on solve operations. * Workaround a division by zero in triangular solve when outerstride==0 * Fix compilation of s`parse.cast<>().transpose()`. * Fix double-conversion warnings throughout the code. * #1207: fix logical-op warnings * #1222, #1223: fix compilation in `AutoDiffScalar`. * #1229: fix usage of `Derived::Options` in MatrixFunctions. * #1224: fix regression in `(dense*dense).sparseView()`. * #1231: fix compilation regression regarding complex_array/=real_array. * #1221: disable gcc 6 warning: ignoring attributes on template argument. * Workaround clang/llvm bug 27908 * #1236: fix possible integer overflow in sparse matrix product. * #1238: fix `SparseMatrix::sum()` overload for un-compressed mode * #1240: remove any assumption on NEON vector types * Improves support for MKL's PARDISO solver. * Fix support for Visual 2010. * Fix support for gcc 4.1. * Fix support for ICC 2016 * Various Altivec/VSX fixes: exp, support for clang 3.9, * #1258: fix compilation of `Map::coeffRef` * #1249: fix compilation with compilers that do not support `__builtin_prefetch` . * #1250: fix `pow()` for `AutoDiffScalar` with custom nested scalar type. ## [3.2.9] Released on July 18, 2016 Changes since 3.2.8: * Main fixes and improvements: * Improve numerical robustness of JacobiSVD (backported from 3.3) * #1017: prevents underflows in `makeHouseholder` * Fix numerical accuracy issue in the extraction of complex eigenvalue pairs in real generalized eigenvalue problems. * Fix support for `vector.homogeneous().asDiagonal()` * #1238: fix `SparseMatrix::sum()` overload for un-compressed mode * #1213: workaround gcc linking issue with anonymous enums. * #1236: fix possible integer overflow in sparse-sparse product * Improve detection of identical matrices when applying a permutation (e.g., `mat = perm * mat`) * Fix usage of nesting type in blas_traits. In practice, this fixes compilation of expressions such as `A*(A*A)^T` * CMake: fixes support of Ninja generator * Add a StorageIndex typedef to sparse matrices and expressions to ease porting code to 3.3 (see http://eigen.tuxfamily.org/index.php?title=3.3#Index_typedef) * #1200: make `aligned_allocator` c++11 compatible (backported from 3.3) * #1182: improve generality of `abs2` (backported from 3.3) * #537: fix compilation of Quaternion with Apples's compiler * #1176: allow products between compatible scalar types * #1172: make `valuePtr` and `innerIndexPtr` properly return null for empty sparse matrices. * #1170: skip calls to `memcpy`/`memmove` for empty inputs. * Others: * #1242: fix comma initializer with empty matrices. * Improves support for MKL's PARDISO solver. * Fix a compilation issue with Pastix solver. * Add some missing explicit scalar conversions * Fix a compilation issue with matrix exponential (unsupported MatrixFunctions module). * #734: fix a storage order issue in unsupported Spline module * #1222: fix a compilation issue in AutoDiffScalar * #1221: shutdown some GCC6's warnings. * #1175: fix index type conversion warnings in sparse to dense conversion. ## [3.2.8] Released on February 16, 2016 Changes since 3.2.7: * Main fixes and improvements: * Make `FullPivLU::solve` use `rank()` instead of `nonzeroPivots()`. * Add `EIGEN_MAPBASE_PLUGIN` * #1166: fix issue in matrix-vector products when the destination is not a vector at compile-time. * #1100: Improve cmake/pkg-config support. * #1113: fix name conflict with C99's "I". * Add missing delete operator overloads in `EIGEN_MAKE_ALIGNED_OPERATOR_NEW` * Fix `(A*B).maxCoeff(i)` and similar. * Workaround an ICE with VC2015 Update1 x64. * #1156: fix several function declarations whose arguments were passed by value instead of being passed by reference * #1164: fix `std::list` and `std::deque` specializations such that our aligned allocator is automatically activatived only when the user did not specified an allocator (or specified the default `std::allocator`). * Others: * Fix BLAS backend (aka MKL) for empty matrix products. * #1134: fix JacobiSVD pre-allocation. * #1111: fix infinite recursion in `sparse_column_major.row(i).nonZeros()` (it now produces a compilation error) * #1106: workaround a compilation issue in Sparse module for msvc-icc combo * #1153: remove the usage of `__GXX_EXPERIMENTAL_CXX0X__` to detect C++11 support * #1143: work-around gcc bug in COLAMD * Improve support for matrix products with empty factors. * Fix and clarify documentation of Transform wrt `operator*(MatrixBase)` * Add a matrix-free conjugate gradient example. * Fix cost computation in CwiseUnaryView (internal) * Remove custom unaligned loads for SSE. * Some warning fixes. * Several other documentation clarifications. ## [3.3-beta1] Released on December 16, 2015 For a comprehensive list of change since the 3.2 series, see this [page](https://www.eigen.tuxfamily.org/index.php?title=3.3). Main changes since 3.3-alpha1: * Dense features: * Add `LU::transpose().solve()` and `LU::adjoint().solve()` API. * Add `Array::rsqrt()` method as a more efficient shorcut for `sqrt().inverse()`. * Add `Array::sign()` method for real and complexes. * Add `lgamma`, `erf`, and `erfc` functions for arrays. * Add support for row/col-wise `lpNorm()`. * Add missing `Rotation2D::operator=(Matrix2x2)`. * Add support for `permutation * homogenous`. * Improve numerical accuracy in LLT and triangular solve by using true scalar divisions (instead of x * (1/y)). * Add `EIGEN_MAPBASE_PLUGIN` and `EIGEN_QUATERNION_PLUGIN`. * #1074: forbid the creation of PlainObjectBase objects. * Sparse features: * Add IncompleteCholesky preconditioner. * Improve support for [matrix-free iterative solvers](http://eigen.tuxfamily.org/dox/group__MatrixfreeSolverExample.html) * Extend `setFromTriplets` API to allow passing a functor object controlling how to collapse duplicated entries. * #918: add access to UmfPack return code and parameters. * Add support for `dense.cwiseProduct(sparse)`, thus enabling `(dense*sparse).diagonal()` expressions. * Add support to directly evaluate the product of two sparse matrices within a dense matrix. * #1064: add support for `Ref`. * Add supports for real mul/div `sparse` operations. * #1086: replace deprecated `UF_long` by `SuiteSparse_long`. * Make `Ref` more versatile. * Performance improvements: * #1115: enable static alignment and thus small size vectorization on ARM. * Add temporary-free evaluation of `D.nolias() *= C + A*B`. * Add vectorization of round, ceil and floor for SSE4.1/AVX. * Optimize assignment into a `Block` by using Ref and avoiding useless updates in non-compressed mode. This make row-by-row filling of a row-major sparse matrix very efficient. * Improve internal cost model leading to faster code in some cases (see changeset 1bcb41187a45). * #1090: improve redux evaluation logic. * Enable unaligned vectorization of small fixed size matrix products. * Misc improvements: * Improve support for `isfinite`/`isnan`/`isinf` in fast-math mode. * Make the IterativeLinearSolvers module compatible with MPL2-only mode by defaulting to COLAMDOrdering and NaturalOrdering for ILUT and ILLT respectively. * Avoid any OpenMP calls if multi-threading is explicitly disabled at runtime. * Make abs2 compatible with custom complex types. * #1109: use noexcept instead of throw for C++11 compilers. * #1100: Improve cmake/pkg-config support. * Countless improvements and fixes in Tensors module. * Most visible fixes: * #1105: fix default preallocation when moving from compressed to uncompressed mode in SparseMatrix. * Fix UmfPackLU constructor for expressions. * Fix degenerate cases in syrk and trsm BLAS API. * Fix matrix to quaternion (and angleaxis) conversion for matrix expression. * Fix compilation of sparse-triangular to dense assignment. * Fix several minor performance issues in the nesting of matrix products. * #1092: fix iterative solver ctors for expressions as input. * #1099: fix missing include for CUDA. * #1102: fix multiple definition linking issue. * #1088: fix setIdenity for non-compressed sparse-matrix. * Fix `SparseMatrix::insert`/`coeffRef` for non-empty compressed matrix. * #1113: fix name conflict with C99's "I". * #1075: fix `AlignedBox::sample` for runtime dimension. * #1103: fix NEON vectorization of `complex` multiplication. * #1134: fix JacobiSVD pre-allocation. * Fix ICE with VC2015 Update1. * Improve cmake install scripts. ## [3.2.7] Released on November 5, 2015 Changes since 3.2.6: * Main fixes and improvements: * Add support for `dense.cwiseProduct(sparse)`. * Fix a regression regarding `(dense*sparse).diagonal()`. * Make the `IterativeLinearSolvers` module compatible with MPL2-only mode by defaulting to `COLAMDOrdering` and `NaturalOrdering` for ILUT and ILLT respectively. * #266: backport support for c++11 move semantic * `operator/=(Scalar)` now performs a true division (instead of `mat*(1/s)`) * Improve numerical accuracy in LLT and triangular solve by using true scalar divisions (instead of `mat * (1/s)`) * #1092: fix iterative solver constructors for expressions as input * #1088: fix `setIdenity` for non-compressed sparse-matrix * #1086: add support for recent SuiteSparse versions * Others: * Add overloads for real-scalar times `SparseMatrix` operations. This avoids real to complex conversions, and also fixes a compilation issue with MSVC. * Use explicit Scalar types for AngleAxis initialization * Fix several shortcomings in cost computation (avoid multiple re-evaluation in some very rare cases). * #1090: fix a shortcoming in redux logic for which slice-vectorization plus unrolling might happen. * Fix compilation issue with MSVC by backporting `DenseStorage::operator=` from devel branch. * #1063: fix nesting of unsupported/AutoDiffScalar to prevent dead references when computing second-order derivatives * #1100: remove explicit `CMAKE_INSTALL_PREFIX` prefix to conform to cmake install's `DESTINATION` parameter. * unsupported/ArpackSupport is now properly installed by make install. * #1080: warning fixes ## [3.2.6] Released on October 1, 2015 Changes since 3.2.5: * fix some compilation issues with MSVC 2013, including bugs #1000 and #1057 * SparseLU: fixes to support `EIGEN_DEFAULT_TO_ROW_MAJOR` (#1053), and for empty (#1026) and some structurally rank deficient matrices (#792) * #1075: fix `AlignedBox::sample()` for Dynamic dimension * fix regression in AMD ordering when a column has only one off-diagonal non-zero (used in sparse Cholesky) * fix Jacobi preconditioner with zero diagonal entries * fix Quaternion identity initialization for non-implicitly convertible types * #1059: fix `predux_max` for NEON * #1039: fix some issues when redefining `EIGEN_DEFAULT_DENSE_INDEX_TYPE` * #1062: fix SelfAdjointEigenSolver for RowMajor matrices * MKL: fix support for the 11.2 version, and fix a naming conflict (#1067) * #1033: explicit type conversion from 0 to RealScalar ## [3.3-alpha1] Released on September 4, 2015 See the [announcement](https://www.eigen.tuxfamily.org/index.php?title=3.3). ## [3.2.5] Released on June 16, 2015 Changes since 3.2.4: * Changes with main impact: * Improve robustness of SimplicialLDLT to semidefinite problems by correctly handling structural zeros in AMD reordering * Re-enable supernodes in SparseLU (fix a performance regression in SparseLU) * Use zero guess in `ConjugateGradients::solve` * Add `PermutationMatrix::determinant` method * Fix `SparseLU::signDeterminant()` method, and add a SparseLU::determinant() method * Allows Lower|Upper as a template argument of CG and MINRES: in this case the full matrix will be considered * #872: remove usage of std::bind* functions (deprecated in c++11) * Numerical robustness improvements: * #1014: improve numerical robustness of the 3x3 direct eigenvalue solver * #1013: fix 2x2 direct eigenvalue solver for identical eigenvalues * #824: improve accuracy of `Quaternion::angularDistance` * #941: fix an accuracy issue in ColPivHouseholderQR by continuing the decomposition on a small pivot * #933: improve numerical robustness in RealSchur * Fix default threshold value in SPQR * Other changes: * Fix usage of `EIGEN_NO_AUTOMATIC_RESIZING` * Improved support for custom scalar types in SparseLU * Improve cygwin compatibility * #650: fix an issue with sparse-dense product and rowmajor matrices * #704: fix MKL support (HouseholderQR) * #705: fix handling of Lapack potrf return code (LLT) * #714: fix matrix product with OpenMP support * #949: add static assertions for incompatible scalar types in many of the dense decompositions * #957, #1000: workaround MSVC/ICC compilation issues when using sparse blocks * #969: fix ambiguous calls to Ref * #972, #986: add support for coefficient-based product with 0 depth * #980: fix taking a row (resp. column) of a column-major (resp. row-major) sparse matrix * #983: fix an alignement issue in Quaternion * #985: fix RealQZ when either matrix had zero rows or columns * #987: fix alignement guess in diagonal product * #993: fix a pitfall with matrix.inverse() * #996, #1016: fix scalar conversions * #1003: fix handling of pointers non aligned on scalar boundary in slice-vectorization * #1010: fix member initialization in IncompleteLUT * #1012: enable alloca on Mac OS or if alloca is defined as macro * Doc and build system: #733, #914, #952, #961, #999 ## [3.2.4] Released on January 21, 2015 Changes since 3.2.3: * Fix compilation regression in Rotation2D * #920: fix compilation issue with MSVC 2015. * #921: fix utilization of bitwise operation on enums in `first_aligned`. * Fix compilation with NEON on some platforms. ## [3.2.3] Released on December 16, 2014 Changes since 3.2.2: * Core: * Enable `Mx0 * 0xN` matrix products. * #859: fix returned values for vectorized versions of `exp(NaN)`, `log(NaN)`, `sqrt(NaN)` and `sqrt(-1)`. * #879: tri1 = mat * tri2 was compiling and running incorrectly if tri2 was not numerically triangular. Workaround the issue by evaluating mat*tri2 into a temporary. * #854: fix numerical issue in SelfAdjointEigenSolver::computeDirect for 3x3 matrices. * #884: make sure there no call to malloc for zero-sized matrices or for a Ref<> without temporaries. * #890: fix aliasing detection when applying a permutation. * #898: MSVC optimization by adding inline hint to const_cast_ptr. * #853: remove enable_if<> in Ref<> ctor. * Dense solvers: * #894: fix the sign returned by LDLT for multiple calls to `compute()`. * Fix JacobiSVD wrt underflow and overflow. * #791: fix infinite loop in JacobiSVD in the presence of NaN. * Sparse: * Fix out-of-bounds memory write when the product of two sparse matrices is completely dense and performed using pruning. * UmfPack support: fix redundant evaluation/copies when calling `compute()`, add support for generic expressions as input, and fix extraction of the L and U factors (#911). * Improve `SparseMatrix::block` for const matrices (the generic path was used). * Fix memory pre-allocation when permuting inner vectors of a sparse matrix. * Fix `SparseQR::rank` for a completely empty matrix. * Fix `SparseQR` for row-major inputs. * Fix `SparseLU::absDeterminant` and add respective unit test. * BiCGSTAB: make sure that good initial guesses are not destroyed by a bad preconditioner. * Geometry: * Fix `Hyperplane::Through(a,b,c)` when points are aligned or identical. * Fix linking issues in OpenGLSupport. * OS, build system and doc: * Various compilation fixes including: #821, #822, #857, #871, #873. * Fix many compilation warnings produced by recent compilers including: #909. * #861: enable posix_memalign with PGI. * Fix BiCGSTAB doc example. ## [3.2.2] Released on August 4, 2014 Changes since 3.2.1: * Core: * Relax Ref such that `Ref` accepts a `RowVectorXf` which can be seen as a degenerate `MatrixXf(1,N)` * Fix performance regression for the vectorization of sub columns/rows of matrices. * `EIGEN_STACK_ALLOCATION_LIMIT`: Raise its default value to 128KB, make use of it to assert on maximal fixed size object, and allows it to be 0 to mean "no limit". * #839: Fix 1x1 triangular matrix-vector product. * #755: `CommaInitializer` produced wrong assertions in absence of Return-Value-Optimization. * Dense solvers: * Add a `rank()` method with threshold control to JacobiSVD, and make solve uses it to return the minimal norm solution for rank-deficient problems. * Various numerical fixes in JacobiSVD, including:#843, and the move from Lapack to Matlab strategy for the default threshold. * Various numerical fixes in LDLT, including the case of semi-definite complex matrices. * Fix `ColPivHouseholderQR::rank()`. * #222: Make temporary matrix column-major independently of `EIGEN_DEFAULT_TO_ROW_MAJOR` in BlockHouseholder. * Sparse: * #838: Fix `dense * sparse` and `sparse * dense` outer products and detect outer products from either the lhs or rhs. * Make the ordering method of SimplicialL[D]LT configurable. * Fix regression in the restart mechanism of BiCGSTAB. * #836: extend SparseQR to support more columns than rows. * #808: Use double instead of float for the increasing size ratio in `CompressedStorage::resize`, fix implicit conversions from int/longint to float/double, and fix `set_from_triplets` temporary matrix type. * #647: Use `smart_copy` instead of bitwise memcpy in CompressedStorage. * GMRES: Initialize essential Householder vector with correct dimension. * Geometry: * #807: Missing scalar type cast in `umeyama()` * #806: Missing scalar type cast in `Quaternion::setFromTwoVectors()` * #759: Removed hard-coded double-math from `Quaternion::angularDistance`. * OS, build system and doc: * Fix compilation with Windows CE. * Fix some ICEs with VC11. * Check IMKL version for compatibility with Eigen * #754: Only inserted (`!defined(_WIN32_WCE)`) analog to alloc and free implementation. * #803: Avoid `char*` to `int*` conversion. * #819: Include path of details.h file. * #738: Use the "current" version of cmake project directories to ease the inclusion of Eigen within other projects. * #815: Fix doc of FullPivLU wrt permutation matrices. * #632: doc: Note that `dm2 = sm1 + dm1` is not possible * Extend AsciiQuickReference (real, imag, conjugate, rot90) ## [3.2.1] Released on February 26, 2014 Changes since 3.2.0: * Eigen2 support is now deprecated and will be removed in version 3.3. * Core: * Bug fix for Ref object containing a temporary matrix. * #654: Allow construction of row vector from 1D array. * #679: Support `cwiseMin()` and `cwiseMax()` on maps. * Support `conservativeResize()` on vectors. * Improve performance of vectorwise and replicate expressions. * #642: Add vectorization of sqrt for doubles, and make sqrt really safe if `EIGEN_FAST_MATH` is disabled. * #616: Try harder to align columns when printing matrices and arrays. * #579: Add optional run-time parameter to fixed-size block methods. * Implement `.all()` and `.any()` for zero-sized objects * #708: Add placement new and delete for arrays. * #503: Better C++11 support. * Dense linear algebra: * #689: Speed up some matrix-vector products by using aligned loads if possible. * Make solve in `FullPivHouseholderQR` return least-square solution if there is no exact solution. * #678: Fix `fullPivHouseholderQR` for rectangular matrices. * Fix a 0/0 issue in JacobiSVD. * #736: Wrong result in `LDLT::isPositiveDefinite()` for semi-definite matrices. * #740: Fix overflow issue in `stableNorm()`. * Make pivoting HouseholderQR compatible with custom scalar types. * Geometry: * Fix compilation of Transform * UniformScaling * Sparse matrices: * Fix elimination tree and SparseQR for fat rectangular matrices. * #635: add `isCompressed` to `MappedSparseMatrix` for compatibility. * #664: Support iterators without `operator<` in `setFromTriplets()`. * Fixes in SparseLU: infinite loop, aliasing issue when solving, overflow in memory allocation, use exceptions only if enabled (#672). * Fixes in SparseQR: reduce explicit zero, assigning result to map, assert catching non-conforming sizes, memory leak. * #681: Uninitialized value in CholmodSupport which may lead to incorrect results. * Fix some issues when using a non-standard index type (#665 and more) * Update constrained CG (unsupported module) to Eigen3. * OS and build system: * MacOS put OpenGL header files somewhere else from where we expected it. * Do not assume that `alloca()` is 16-byte aligned on Windows. * Compilation fixes when using ICC with Visual Studio. * Fix Fortran compiler detection in CMake files. * Fix some of our tests (bugs #744 and #748 and more). * Fix a few compiler warnings (bug #317 and more). * Documentation fixes (bugs #609, #638 and #739 and more). ## [3.1.4] Released on August 02, 2013 Changes since 3.1.3: * #620: Fix robustness and performance issues in JacobiSVD::solve. * #613: Fix accuracy of SSE sqrt for very small numbers. * #608: Fix sign computation in LDLT. * Fix write access to CwiseUnaryView expressions. * Fix compilation of `transposeInPlace()` for Array expressions. * Fix non const `data()` member in Array and Matrix wrappers. * Fix a few warnings and compilation issues with recent compiler versions. * Documentation fixes. ## [3.0.7] Released on August 02, 2013 Changes since 3.0.6: * Fix traits of `Map`. * Fix a few warnings (#507) and documentation (#531). ## [3.2.0] Released on July 24, 2013. Major new features and optimizations since 3.1: * Dense world * New [`Ref<>`](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1Ref.html) class allowing to write non templated function taking various kind of Eigen dense objects without copies. * New [RealQZ](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1RealQZ.html) factorization and [GeneralizedEigenSolver](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1GeneralizedEigenSolver.html). * Add vector-wise normalized and normalize functions, and hasNaN/allFinite members. * Add mixed static/dynamic-size `.block<.,.>()` functions. * Optimize outer products for non rank-1 update operations. * Optimize diagonal products (enable vectorization in more cases). * Improve robustness and performance in `JacobiSVD::solve()`. * Sparse world * New [SparseLU](http://eigen.tuxfamily.org/dox-devel/group__SparseLU__Module.html) module: built-in sparse LU with supernodes and numerical row pivoting (port of SuperLU making the SuperLUSupport module obsolete). * New [SparseQR](http://eigen.tuxfamily.org/dox-devel/group__SparseQR__Module.html) module: rank-revealing sparse QR factorization with numerical column pivoting. * New [COLAMD](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1COLAMDOrdering.html) ordering and unified [ordering API](http://eigen.tuxfamily.org/dox-devel/group__OrderingMethods__Module.html). * Add support for generic blocks of sparse matrices (read-only). * Add conservative resize feature on sparse matrices. * Add uniform support for solving sparse systems with sparse right hand sides. * Add support for sparse matrix time sparse self-adjoint view products. * Improve BiCGSTAB robustness with restart. * Support to external libraries * New [MetisSupport](http://eigen.tuxfamily.org/dox-devel/group__MetisSupport__Module.html) module: wrapper to the famous graph partitioning library. * New [SPQRSupport](http://eigen.tuxfamily.org/dox-devel/group__SPQRSupport__Module.html) module: wrapper to suitesparse's supernodal QR solver. Eigen 3.2 represents about 600 commits since Eigen 3.1. ## [3.2-rc2] Released on July 19, 2013. Changes since 3.2-rc1: * Rename `DenseBase::isFinite()` to `allFinite()` to avoid a future naming collision. * Fix an ICE with ICC 11.1. ## [3.2-rc1] Released on July 17, 2013. Main changes since 3.2-beta1: * New features: * #562: Add vector-wise normalized and normalize functions. * #564: Add `hasNaN` and `isFinite` members. * #579: Add support for mixed static/dynamic-size `.block()`. * #588: Add support for determinant in SparseLU. * Add support in SparseLU to solve with L and U factors independently. * Allow multiplication-like binary operators to be applied on type combinations supported by `scalar_product_traits`. * #596: Add conversion from `SparseQR::matrixQ()` to a `SparseMatrix`. * #553: Add support for sparse matrix time sparse self-adjoint view products. * Accuracy and performance: * Improve BiCGSTAB robustness: fix a divide by zero and allow to restart with a new initial residual reference. * #71: Enable vectorization of diagonal products in more cases. * #620: Fix robustness and performance issues in JacobiSVD::solve. * #609: Improve accuracy and consistency of the eulerAngles functions. * #613: Fix accuracy of SSE sqrt for very small numbers. * Enable SSE with ICC even when it mimics a gcc version lower than 4.2. * Add SSE4 min/max for integers. * #590 & #591: Minor improvements in NEON vectorization. * Bug fixes: * Fix `HouseholderSequence::conjugate()` and `::adjoint()`. * Fix SparseLU for dense matrices and matrices in non compressed mode. * Fix `SparseMatrix::conservativeResize()` when one dimension is null. * Fix `transposeInpPlace` for arrays. * Fix `handmade_aligned_realloc`. * #554: Fix detection of the presence of `posix_memalign` with mingw. * #556: Workaround mingw bug with `-O3` or `-fipa-cp-clone` options. * #608: Fix sign computation in LDLT. * #567: Fix iterative solvers to immediately return when the initial guess is the true solution and for trivial solution. * #607: Fix support for implicit transposition from dense to sparse vectors. * #611: Fix support for products of the form `diagonal_matrix * sparse_matrix * diagonal_matrix`. * Others: * #583: Add compile-time assertion to check DenseIndex is signed. * #63: Add lapack unit tests. They are automatically downloaded and configured if `EIGEN_ENABLE_LAPACK_TESTS` is ON. * #563: Assignment to `Block` is now allowed on non-compressed matrices. * #626: Add assertion on input ranges for coeff* and insert members for sparse objects. * #314: Move special math functions from internal to numext namespace. * Fix many warnings and compilation issues with recent compiler versions. * Many other fixes including #230, #482, #542, #561, #564, #565, #566, #578, #581, #595, #597, #598, #599, #605, #606, #615. ## [3.1.3] Released on April 16, 2013 Changes since 3.1.2: * #526 - Fix linear vectorized transversal in linspace. * #551 - Fix compilation issue when using `EIGEN_DEFAULT_DENSE_INDEX_TYPE`. * #533 - Fix some missing const qualifiers in Transpose * Fix a compilation with CGAL::Gmpq by adding explicit internal:: namespace when calling `abs()`. * Fix computation of outer-stride when calling `.real()` or `.imag()`. * Fix `handmade_aligned_realloc` (affected `conservativeResize()`). * Fix sparse vector assignment from a sparse matrix. * Fix `log(0)` with SSE. * Fix bug in aligned_free with windows CE. * Fix traits of `Map`. * Fix a few warnings (#507, #535, #581). * Enable SSE with ICC even when it mimics a gcc version lower than 4.2 * Workaround [gcc-4.7 bug #53900](http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53900) (too aggressive optimization in our alignment check) ## [3.2-beta1] Released on March 07, 2013 Main changes since 3.1: * Dense modules * A new [`Ref<>`](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1Ref.html) class allowing to write non templated function taking various kind of Eigen dense objects without copies. * New [RealQZ](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1RealQZ.html) factorization and [GeneralizedEigenSolver](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1GeneralizedEigenSolver.html) * Optimized outer products for non rank-1 update operations. * Sparse modules * New [SparseLU](http://eigen.tuxfamily.org/dox-devel/group__SparseLU__Module.html) module: built-in sparse LU with supernodes and numerical row pivoting (port of SuperLU making the SuperLUSupport module obsolete). * New [SparseQR](http://eigen.tuxfamily.org/dox-devel/group__SparseQR__Module.html) module: rank-revealing sparse QR factorization with numerical column pivoting. * OrderingMethods: extended with [COLAMD](http://eigen.tuxfamily.org/dox-devel/classEigen_1_1COLAMDOrdering.html) ordering and a unified [ordering](http://eigen.tuxfamily.org/dox-devel/group__OrderingMethods__Module.html) API. * Support for generic blocks of sparse matrices. * Add conservative resize feature on sparse matrices. * Add uniform support for solving sparse systems with sparse right hand sides. * Support to external libraries * New [MetisSupport](http://eigen.tuxfamily.org/dox-devel/group__MetisSupport__Module.html) module: wrapper to the famous graph partitioning library. * New [SPQRSupport](http://eigen.tuxfamily.org/dox-devel/group__SPQRSupport__Module.html) module: wrapper to suitesparse's supernodal QR solver. * Misc * Improved presentation and clarity of Doxygen generated documentation (modules are now organized into chapters, treeview panel and search engine for quick navagitation). * New compilation token `EIGEN_INITIALIZE_MATRICES_BY_NAN` to help debugging. * All bug fixes of the 3.1 branch, plus a couple of other fixes (including 211, 479, 496, 508, 552) ## [3.1.2] Released on Nov 05, 2012 Changes since 3.1.1: * #524 - Pardiso's parameter array does not have to be aligned! * #521 - Disable `__cpuidex` on architectures different that x86 or x86-64 with MSVC. * #519 - `AlignedBox::dim()` was wrong for dynamic dimensions. * #515 - Fix missing explicit scalar conversion. * #511 - Fix pretty printers on windows. * #509 - Fix warnings with gcc 4.7 * #501 - Remove aggressive mat/scalar optimization (was replaced by `mat*(1/scalar)` for non integer types). * #479 - Use EISPACK's strategy re max number of iters in Schur decomposition. * Add support for scalar multiple of diagonal matrices. * Forward `resize()` function from Array/Matrix wrappers to the nested expression such that `mat.array().resize(a,b)` is now allowed. * Windows CE: fix the lack of the `aligned_malloc` function on this platform. * Fix comma initializer when inserting empty matrices. * Fix `dense=sparse*diagonal` products. * Fix compilation with `m.array().min(scalar)` and `m.array().max(scalar)`. * Fix out-of-range memory access in GEMV (the memory was not used for the computation, only to assemble unaligned packets from aligned packet loads). * Fix various regressions with MKL support. * Fix aliasing issue in sparse matrix assignment. * Remove stupid assert in blue norm. * Workaround a weird compilation error with MSVC. ## [3.1.1] Released on July 22, 2012 Changes since 3.1.0: * [relicense to MPL2](https://www.eigen.tuxfamily.org/index.php?title=Main_Page#License) * add a `EIGEN_MPL2_ONLY` build option to generate compiler errors when including non-MPL2 modules * remove dynamic allocation for triangular matrix-matrix products of fixed size objects * Fix possible underflow issues in SelfAdjointEigenSolver * Fix issues with fixed-size Diagonal (sub/super diagonal size computation was wrong) * #487 - Geometry module: `isometry * scaling` compilation error * #486 - MKL support: fixed multiple-references linker errors with various decompositions * #480 - work around compilation error on Android NDK due to isfinite being defined as a macro * #485 - IterativeLinearSolvers: conflict between a typedef and template type parameter * #479 - Eigenvalues/Schur: Adjust max iterations count to matrix size * Fixed Geometry module compilation under MSVC * Fixed Sparse module compilation under MSVC 2005 ## [3.0.6] Released on July 9, 2012 Changes since 3.0.5: * #447 - fix infinite recursion in `ProductBase::coeff()` * #478 - fix RealSchur on a zero matrix * #477 - fix warnings with gcc 4.7 * #475 - `.exp()` now returns `+inf` when overflow occurs (SSE) * #466 - fix a possible race condition in OpenMP environment (for non OpenMP thread model it is recommended to upgrade to 3.1) * #362 - fix missing specialization for affine-compact `*` projective * #451 - fix a clang warning * Fix compilation of `somedensematrix.llt().matrixL().transpose()` * Fix miss-use of the cost-model in Replicate * Fix use of int versus Index types for `Block::m_outerStride` * Fix ambiguous calls to some std functions * Fix geometry tutorial on scalings * Fix RVCT 3.1 compiler errors * Fix implicit scalar conversion in Transform * Fix typo in NumericalDiff (unsupported module) * Fix LevenbergMarquart for non double scalar type (unsupported module) ## [3.1.0] Released on June 24, 2012. Major changes between Eigen 3.0 and Eigen 3.1: * New features * **New set of officially supported Sparse Modules** ** This includes sparse matrix storage, assembly, and many built-in (Cholesky, CG, BiCGSTAB, ILU), and third-party (PaStiX, Cholmod, UmfPack, SuperLU, Pardiso) solvers ** See this [page](http://eigen.tuxfamily.org/dox-devel/TutorialSparse.html) for an overview of the features * **Optional support for Intel MKL** ** This includes the BLAS, LAPACK, VML, and Pardiso components ** See this [page](http://eigen.tuxfamily.org/dox-devel/TopicUsingIntelMKL.html) for the details * Core ** New vector-wise operators: `*`, `/`, `*=`, `/=` ** New coefficient-wise operators: `&&`, `||`, `min(Scalar)`, `max(Scalar)`, `pow`, `operator/(Scalar,ArrayBase)` * Decompositions ** Add incremental rank-updates in LLTand LDLT ** New `SelfAdjointEigenSolver::computeDirect()` function for fast eigen-decomposition through closed-form formulas (only for 2x2 and 3x3 real matrices) * Optimizations * Memory optimizations in JacobiSVD and triangular solves. * Optimization of reductions via partial unrolling (e.g., dot, sum, norm, etc.) * Improved performance of small matrix-matrix products and some Transform<> operations Eigen 3.1 represents about 600 commits since Eigen 3.0. ## [3.1.0-rc2] Released on June 21, 2012. Changes since 3.1.0-rc1: * Fix a couple of compilation warnings * Improved documentation, in particular regarding the Geometry and Sparse tutorials, and sparse solver modules * Fix double preconditioner allocation in `JacobiSVD` * #466: `RealSchur` failed on a zero matrix * Update Adolc and MPReal support modules ## [3.1.0-rc1] Released on June 14, 2012 Main changes since 3.1.0-beta1: * #466: fix a possible race condition issue. from now, multithreaded applications that call Eigen from multiple thread must initialize Eigen by calling `initParallel()`. * For consistency, `SimplicialLLT` and `SimplicialLDLT` now factorizes `P A P^-1` (instead of `P^-1 A P`). * #475: now the vectorized `exp` operator returns +inf when overflow occurs * Fix the use of MKL with MSVC by disabling MKL's pow functions. * Avoid dynamic allocation for fixed size triangular solving * Fix a compilation issue with ICC 11.1 * Fix ambiguous calls in the math functors * Fix BTL interface. ## [3.1.0-beta1] Released on June 7, 2012 Main changes since 3.1.0-alpha2: * **API changes** * `SimplicialLLt` and `SimplicialLDLt` are now renamed `SimplicialLLT` and `SimplicialLDLT` for consistency with the other modules. * The Pardiso support module is now spelled "PardisoSupport" * Dense modules: * Add `operator/(Scalar,ArrayBase)` and coefficient-wise pow operator. * Fix automatic evaluation of expressions nested by Replicate (performance improvement) * #447 - fix infinite recursion in `ProductBase::coeff()` * #455 - add support for c++11 in `aligned_allocator` * `LinSpace`: add a missing variant, and fix the size=1 case * Sparse modules: * Add an **IncompleteLU** preconditioner with dual thresholding. * Add an interface to the parallel **Pastix** solver * Improve applicability of permutations (add `SparseMatrixBase::twistedBy`, handle non symmetric permutations) * `CholmodDecomposition` now has explicit variants: `CholmodSupernodalLLT`, `CholmodSimplicialLLT`, `CholmodSimplicialLDLT` * Add analysePattern/factorize methods to iterative solvers * Preserve explicit zero in a sparse assignment * Speedup `sparse * dense` products * Fix a couple of issues with Pardiso support * Geometry module: * Improve performance of some `Transform<>` operations by better preserving the alignment status. * #415 - wrong return type in `Rotation2D::operator*=` * #439 - add `Quaternion::FromTwoVectors()` static constructor * #362 - missing specialization for affine-compact `*` projective * Others: * add support for RVCT 3.1 compiler * New tutorial page on Map * and many other bug fixes such as: #417, #419, #450 ## [3.0.5] Released February 10, 2012 Changes since 3.0.4: * #417 - fix nesting of `Map` expressions * #415 - fix return value of `Rotation2D::operator*=` * #410 - fix a possible out of range access in `EigenSolver` * #406 - fix infinite loop/deadlock when using OpenMP and Eigen * Changeset 4462 - fix broken asserts revealed by Clang * Changeset 4457 - fix description of `rankUpdate()` in quick reference guide * Changeset 4455 - fix out-of-range int constant in 4x4 inverse * #398 - fix in slerp: the returned quaternion was not always normalized * Changeset 4432 - fix asserts in eigenvalue decompositions * Changeset 4416 - fix MSVC integer overflow warning ## [3.1.0-alpha2] Released February 6, 2012 Main changes since 3.0.1-alpha1: * New optional support for Intel MKL and other BLAS including: ([details](http://eigen.tuxfamily.org/dox-devel/TopicUsingIntelMKL.html)) * BLAS (arbitrary BLAS) * Intel LAPACKE * Intel VML (coefficient-wise math operations) * Intel PARDISO (sparse direct solver) * Dense modules: * improved performance of small matrix-matrix products * Feature #319 - add a rankUpdate function to LDLt and LLT for updates/downdates * Feature #400 - new coefficient wise min/max functions taking one scalar argument * Sparse modules: * new fast sparse matrix assembly interface from a random list of triplets (see `SparseMatrix::setFromTriplets()`) * new shifting feature in SimplicialCholesky (see `SimplicialCholeskyBase::setShift()`) * add checks for positive definiteness in SimplicialCholesky * improved heuristic to predict the nnz of a `sparse*sparse` product * add support for uncompressed SparseMatrix in CholmodSupport * Geometry module: * Feature #297 - add `ParametrizedLine::intersectionPoint()` and `intersectionParam()` functions * Others: * fix many warnings and compilation issues with ICC 12 and -strict-ansi * fix some ICE with MSVC10 * add the possibility to disable calls to cpuid (`-DEIGEN_NO_CPUID`) and other asm directives * and many other bug fixes such as: #406, #410, #398, #396, #394, #354, #352, #301, ## [3.1.0-alpha1] Released December 6, 2011 Main changes since 3.0: * Officially supported set of sparse modules. See this [page](http://eigen.tuxfamily.org/dox-devel/TutorialSparse.html) for an overview of the features. Main changes: * new `SparseCore` module equivalent to the old `Sparse` module, the `Sparse` module is now a super module including all sparse-related modules * the `SparseMatrix` class is now more versatile and supports an uncompressed mode for fast element insertion * the `SparseMatrix` class now offer a unique and simplified API to insert elements * `DynamicSparseMatrix` has been deprecated (moved into `unsupported/SparseExtra`) * new conservative `sparse * sparse` matrix product which is also used by default * new `SparseCholesky` module featuring the SimplicialLLT and SimplicialLDLT built-in solvers * new `IterativeLinearSolvers` module featuring a conjugate gradient and stabilized bi-conjugate gradient iterative solvers with a basic Jacobi preconditioner * New `SelfAdjointEigenSolver::computeDirect()` function for fast eigen-decomposition through closed-form formulas (only for 2x2 and 3x3 real matrices) * New `LLT::rankUpdate()` function supporting both updates and down-dates * Optimization of reduction via partial unrolling (e.g., dot, sum, norm, etc.) * New coefficient-wise operators: `&&` and `||` * Feature #157 - New vector-wise operations for arrays: `*`, `/`, `*=`, and `/=`. * Feature #206 - Pre-allocation of intermediate buffers in JacobiSVD * Feature #370 - New typedefs for AlignedBox * All the fixes and improvements of the 3.0 branch up to the 3.0.4 release (see below) ## [3.0.4] Released December 6, 2011 Changes since 3.0.3: * #363 - check for integer overflow in size computations * #369 - Quaternion alignment is broken (and more alignment fixes) * #354 - Converge better in SelfAdjointEigenSolver, and allow better handling of non-convergent cases * #347 - Fix compilation on ARM NEON with LLVM 3.0 and iOS SDK 5.0 * #372 - Put unsupported modules documentation at the right place * #383 - Fix C++11 compilation problem due to some constructs mis-interpreted as c++11 user-defined literals * #373 - Compilation error with clang 2.9 when exceptions are disabled * Fix compilation issue with `QuaternionBase::cast` ## [2.0.17] Released December 6, 2011 Changes since 2.0.16: * Fix a compilation bug in `aligned_allocator`: the allocate method should take a void pointer * Fix a typo in ParametrizedLine documentation ## [3.0.3] Released October 6, 2011 Changes since 3.0.2: * Fix compilation errors when Eigen2 support is enabled. * Fix bug in evaluating expressions of the form `matrix1 * matrix2 * scalar1 * scalar2`. * Fix solve using LDLT for singular matrices if solution exists. * Fix infinite loop when computing SVD of some matrices with very small numbers. * Allow user to specify pkgconfig destination. * Several improvements to the documentation. ## [3.0.2] Released August 26, 2011 Changes since 3.0.1: * `Windows.h`: protect min/max calls from macros having the same name (no need to `#undef` min/max anymore). * MinGW: fix compilation issues and pretty gdb printer. * Standard compliance: fix aligned_allocator and remove uses of long long. * MPReal: updates for the new version. * Other fixes: * fix aligned_stack_memory_handler for null pointers. * fix std::vector support with gcc 4.6. * fix linking issue with OpenGL support. * fix SelfAdjointEigenSolver for 1x1 matrices. * fix a couple of warnings with new compilers. * fix a few documentation issues. ## [3.0.1] Released May 30, 2011 Changes since 3.0.0: * Fix many bugs regarding ARM and NEON (Now all tests succeed on ARM/NEON). * Fix compilation on gcc 4.6 * Improved support for custom scalar types: * Fix memory leak issue for scalar types throwing exceptions. * Fix implicit scalar type conversion. * Math functions can be defined in the scalar type's namespace. * Fix bug in trapezoidal matrix time matrix product. * Fix asin. * Fix compilation with MSVC 2005 (SSE was wrongly enabled). * Fix bug in `EigenSolver`: normalize the eigen vectors. * Fix Qt support in Transform. * Improved documentation. ## [2.0.16] Released May 28, 2011 Changes since 2.0.15: * Fix bug in 3x3 tridiagonlisation (and consequently in 3x3 selfadjoint eigen decomposition). * Fix compilation for new gcc 4.6. * Fix performance regression since 2.0.12: in some matrix-vector product, complex matrix expressions were not pre-evaluated. * Fix documentation of Least-Square. * New feature: support for `part`. * Fix bug in SparseLU::setOrderingMethod. ## [3.0.0] Released March 19, 2011, at the [meeting](https://www.eigen.tuxfamily.org/index.php?title=Paris_2011_Meeting). See the [Eigen 3.0 release notes](https://www.eigen.tuxfamily.org/index.php?title=3.0). Only change since 3.0-rc1: * Fixed compilation of the unsupported 'openglsupport' test. ## [3.0-rc1] Released March 14, 2011. Main changes since 3.0-beta4: * Core: added new `EIGEN_RUNTIME_NO_MALLOC` option and new `set_is_malloc_allowed()` option to finely control where dynamic memory allocation is allowed. Useful for unit-testing of functions that must not cause dynamic memory allocations. * Core: SSE performance fixes (follow-up from #203). * Core: Fixed crashes when using `EIGEN_DONT_ALIGN` or `EIGEN_DONT_ALIGN_STATICALLY` (#213 and friends). * Core: `EIGEN_DONT_ALIGN` and `EIGEN_DONT_ALIGN_STATICALLY` are now covered by unit tests. * Geometry: Fixed transform * matrix products (#207). * Geometry: compilation fix for mixing CompactAffine with Homogeneous objects * Geometry: compilation fix for 1D transform * SVD: fix non-computing constructors (correctly forward `computationOptions`) (#206) * Sparse: fix resizing when the destination sparse matrix is row major (#37) * more Eigen2Support improvements * more unit test fixes/improvements * more documentation improvements * more compiler warnings fixes * fixed GDB pretty-printer for dynamic-size matrices (#210) ## [3.0-beta4] Released February 28, 2011. Main changes since 3.0-beta3: * Non-vectorization bug fixes: * fix #89: work around an extremely evil compiler bug on old GCC (<= 4.3) with the standard `assert()` macro * fix Umfpack back-end in the complex case * Vectorization bug fixes: * fix a segfault in "slice vectorization" when the destination might not be aligned on a scalar (`complex`) * fix #195: fast SSE unaligned loads fail on GCC/i386 and on Clang * fix #186: worked around a GCC 4.3 i386 backend issue with SSE * fix #203: SSE: a workaround used in pset1() resulted in poor assembly * worked around a GCC 4.2.4 internal compiler error with vectorization of complex numbers * lots of AltiVec compilation fixes * NEON compilation fixes * API additions and error messages improvements * Transform: prevent bad user code from compiling * fix #190: directly pass Transform Options to Matrix, allowing to use RowMajor. Fix issues in Transform with non-default Options. * factorize implementation of standard real unary math functions, and add acos, asin * Build/tests system * Lots of unit test improvements * fix installation of unsupported modules * fixed many compiler warnings, especially on the Intel compiler and on LLVM/Clang * CTest/CMake improvements * added option to build in 32bit mode * BLAS/LAPACK implementation improvements * The Blas library and tests are now automatically built as part of the tests. * expanded LAPACK interface (including syev) * now Sparse solver backends use our own BLAS/LAPACK implementation * fix #189 (cblat1 test failure) * Documentation * improved conservativeResize methods documentation * documented sorting of eigenvalues * misc documentation improvements * improve documentation of plugins ## [3.0-beta3] Released February 12, 2011. The biggest news is that the API is now **100% stable**. Main changes since 3.0-beta2: * The "too many to list them all" category: * lots of bug fixes * lots of performance fixes * lots of compiler support fixes * lots of warning fixes * lots of unit tests improvements and fixes * lots of documentation improvements * lots of build system fixes * API changes: * replaced `ei_` prefix by `internal::` namespace. For example, `ei_cos(x)` becomes `internal::cos(x)`. * renamed `PlanarRotation` -> `JacobiRotation` * renamed `DenseStorageBase` -> `PlainObjectBase` * HouseholderSequence API cleanup * refactored internal metaprogramming helpers to follow closely the standard library * made UpperBidiagonalization internal * made BandMatrix/TridiagonalMatrix internal * Core: also see below, "const correctness". * Sparse: `EIGEN_YES_I_KNOW_SPARSE_MODULE_IS_NOT_STABLE_YET` must be defined to use Eigen/Sparse * Core: `random()` now spans over range of width `RAND_MAX` * New API: * Core: added Map static methods taking strides * SVD: added `jacobiSvd()` method * Sparse: many misc improvements and new features. Improved support for Cholmod, Amd, SuperLU and other back-ends. * Core: allow mixed real-complex dot products * Geometry: allow mixed real-complex cross products * Geometry: allow to pass Options parameters to Transform, Quaternion and other templates, to control memory alignment * QR: add threshold API to FullPivHouseholderQR * Core: added tan function * Const correctness: * Eigen now properly enforces const-correctness everywhere, for example with Map objects. This will break compilation of code that relied on former behavior. * A new kind of test suite was added to check that, 'failtest'. * BLAS/LAPACK: * Complete BLAS library built on top of Eigen. Imported BLAS test suite, which allowed to fix many issues. * Partial LAPACK implementation. Passing part of the LAPACK test suite, which also allowed to fix some issues. * Eigen 2 Support: * tons of improvements in `EIGEN2_SUPPORT` * new incremental migration path: see http://eigen.tuxfamily.org/dox-devel/Eigen2SupportModes.html * imported a copy of the Eigen 2 test suite, made sure that Eigen 3 passes it. That also allowed to fix several issues. ## [3.0-beta2] Released October 15, 2010. Main changes since 3.0-beta1: * Add support for the vectorization of `std::complex<>` with SSE, AltiVec and NEON. * Add support for mixed `real * complex` matrix products with vectorization. * Finalize the JacobiSVD class with: compile time options, thin/full decompositions, and least-square solving. * Several improvement of the Transform class. In particular, there is no default mode anymore. * New methods: `middleRows()`, `middleCols()`, `TriangularMatrix::conjugate()` * New unsupported modules: OpenGL, MPFR C++ * Many improvements in the support of empty objects. * Many improvements of the vectorization logic. * Add the possibility to extend QuaternionBase. * Vectorize Quaternion multiplication with double. * Significant improvements of the documentation. * Improved compile time errors. * Enforce static allocation of temporary buffers in gemm (when possible). * Fix aligned_delete for null pointers and non trivial dtors. * Fix eigen decomposition of 3x3 float matrices. * Fix 4x4 matrix inversions (vectorization). * Many fixes in QR: solving with `m>n`, use of rank, etc. * Fixes for MSVC for windows mobile and CLang. * Remove the Taucs backend (obsolete). * Remove the old SVD class (was causing too much troubles, a new decompozition based on bidiagonalisation/householder should come back soon, `JacobiSVD` can be used meanwhile). ## [2.0.15] Released July 16, 2010 Changes since 2.0.14: * Fix bug: certain cases of matrix-vector product (depending on storage order) were blocked by an assertion failure. * Fix LU and QR solve when rank==0, fix LLT when the matrix is purely 0. * Fix a couple of bugs with QR solving especially with rows>cols. * Fix bug with custom scalar types that have non-trivial destructor. * Fix for ICC in SSE code. * Fix some C++ issues found by Clang (patch by Nick Lewycky). ## [3.0-beta1] Released July 5, 2010 See the [announcement](https://www.eigen.tuxfamily.org/index.php?title=3.0). ## [2.0.14] Released June 22, 2010 Changes since 2.0.13: * Fix #141: crash in SSE (alignment problem) when using dynamic-size matrices with a max-size fixed at compile time that is not a multiple of 16 bytes. For example, `Matrix`. * Fix #142: LU of fixed-size matrices was causing dynamic memory allocation (patch by Stuart Glaser). * Fix #127: remove useless static keywords (also fixes warnings with clang++). ## [2.0.13] Released June 10, 2010 Changes since 2.0.12: * Fix #132: crash in certain matrix-vector products. Unit test added. * Fix #125: colwise `norm()` and `squaredNorm()` on complex types do not return real types * Fully support the QCC/QNX compiler (thanks to Piotr Trojanek). The support in 2.0.12 was incomplete. The whole test suite is now successful. * As part of the QCC support work, a lot of standards compliance work: put `std::` in front of a lot of things such as `size_t`, check whether the math library needs to be linked to explicitly. * Fix precision issues in LDLT. The `isPositiveDefinite()` method is now always returning true, but it was conceptually broken anyway, since a non-pivoting LDLT decomposition can't know that. * Compilation fix in `ldlt()` on expressions. * Actually install the Eigen/Eigen and Eigen/Dense public headers! * Fix readcost for complex types. * Fix compilation of the BTL benchmarks. * Some dox updates. ## [2.0.12] Released February 12, 2010 Changes since 2.0.11: * `EIGEN_DEFAULT_TO_ROW_MAJOR` is fully supported and tested. * Several important fixes for row-major matrices. * Fix support of several algorithms for mixed fixed-dynamic size matrices where the fixed dimension is greater than the dynamic dimension. For example: `Matrix(3,2)` * fix `EIGEN_DONT_ALIGN`: now it _really_ disables vectorization (was giving a `#error` unless you also used `EIGEN_DONT_VECTORIZE`). * Fix #92: Support QNX's QCC compiler (patch by Piotr Trojanek) * Fix #90, missing type cast in LU, allow to use LU with MPFR (patch by 'Wolf'). * Fix ICC compiler support: work around a bug present at least in ICC 11.1. * Compilation fixes for `computeInverse()` on expressions. * Fix a gap in a unit-test (thanks to Jitse Niesen) * Backport improvements to benchmarking code. * Documentation fixes ## [2.0.11] Released January 10, 2010 Changes since 2.0.10: * Complete rewrite of the 4x4 matrix inversion: we now use the usual cofactors approach, so no numerical stability problems anymore (bug #70) * Still 4x4 matrix inverse: SSE path for the float case, borrowing code by Intel, giving very high performance. * Fix crash happening on 32-bit x86 Linux with SSE, when double's were created at non-8-byte-aligned locations (bug #79). * Fix bug in Part making it crash in certain products (bug #80). * Precision improvements in Quaternion SLERP (bug #71). * Fix sparse triangular solver for lower/row-major matrices (bug #74). * Fix MSVC 2010 compatibility. * Some documentation improvements. ## [2.0.10] Released November 25, 2009 Changes since 2.0.9: * Rewrite 4x4 matrix inverse to improve precision, and add a new unit test to guarantee that precision. It's less fast, but it's still faster than the cofactors method. * Fix bug #62: crash in SSE code with MSVC 2008 (Thanks to Hauke Heibel). * Fix bug #65: `MatrixBase::nonZeros()` was recursing infinitely * Fix PowerPC platform detection on Mac OSX. * Prevent the construction of bogus MatrixBase objects and generate good compilation errors for that. Done by making the default constructor protected, and adding some private constructors. * Add option to initialize all matrices by zero: just #define `EIGEN_INITIALIZE_MATRICES_BY_ZERO` * Improve Map documentation * Install the pkg-config file to share/pkgconfig, instead of lib/pkgconfig (thanks to Thomas Capricelli) * fix warnings * fix compilation with MSVC 2010 * adjust to repository name change ## [2.0.9] Released October 24, 2009 Changes since 2.0.8: * Really fix installation and the pkg-config file. * Install the `NewStdVector` header that was introduced in 2.0.6. ## [2.0.8] Released October 23, 2009 Changes since 2.0.7: * fix installation error introduced in 2.0.7: it was choking on the pkg-config file eigen2.pc not being found. The fix had been proposed long ago by Ingmar Vanhassel for the development branch, and when recently the pkg-config support was back-ported to the 2.0 branch, nobody thought of backporting this fix too, and apparently nobody tested "make install" ! * SVD: add default constructor. Users were relying on the compiler to generate one, and apparenty 2.0.7 triggered a little MSVC 2008 subtlety in this respect. Also added an assert. ## [2.0.7] Released October 22, 2009 Changes since 2.0.6: * fix bug #61: crash when using Qt `QVector` on Windows 32-bit. By Hauke Heibel. * fix bug #10: the `reallocateSparse` function was half coded * fix bug in `SparseMatrix::resize()` not correctly initializing by zero * fix another bug in `SparseMatrix::resize()` when `outerSize==0`. By Hauke Heibel. * fully support GCC 3.3. It was working in 2.0.2, there was a compilation error in 2.0.6, now for the first time in 2.0.7 it's 100% tested (the test suite passes without any errors, warnings, or failed tests). * SVD: add missing assert (help catch mistakes) * fixed warnings in unit-tests (Hauke Heibel) * finish syncing `Memory.h` with the devel branch. This is cleaner and fixes a warning. The choice of system aligned malloc function may be affected by this change. * add pkg-config support by Rhys Ulerich. * documentation fix and doc-generation-script updates by Thomas Capricelli ## [2.0.6] Released September 23, 2009 Changes since 2.0.5: * fix bug: visitors didn't work on row-vectors. * fix bug #50: compilation errors with `swap()`. * fix bug #42: Add `Transform::Identity()` as mentioned in the tutorial. * allow to disable all alignment code by defining `EIGEN_DONT_ALIGN` (backport from devel branch). * backport the devel branch's `StdVector` header as `NewStdVector`. You may also #define `EIGEN_USE_NEW_STDVECTOR` to make `StdVector` use it automatically. However, by default it isn't used by `StdVector`, to preserve compatibility. * Vectorized quaternion product (for float) by Rohit Garg (backport from devel branch). * allow to override `EIGEN_RESTRICT` and add `EIGEN_DONT_USE_RESTRICT_KEYWORD` * fix a warning in `ei_aligned_malloc`; fixed by backporting the body from the devel branch; may result in a different choice of system aligned malloc function. * update the documentation. ## [2.0.5] Released August 22, 2009 Changes since 2.0.4: * fix bug: in rare situations involving mixed storage orders, a matrix product could be evaluated as its own transpose * fix bug: `LU::solve()` crashed when called on the LU decomposition of a zero matrix * fix bug: `EIGEN_STACK_ALLOCATION_LIMIT` was too high, resulting in stack overflow for a user. Now it is set as in the devel branch. * fix compilation bug: our `StdVector` header didn't work with GCC 4.1. (Bug #41) * fix compilation bug: missing return statement in `Rotation2D::operator*=` (Bug #36) * in StdVector, a more useful `#error` message about the #including order * add `EIGEN_TRANSFORM_PLUGIN` allowing to customize the Transform class * fix a warning with MSVC * fix a bug in our cmake code when building unit-tests (thanks to Marcus Hanwell) * work around a bug in cmake that made it fail to build unit-tests when fortran wasn't installed * in our cmake code, remove the part about retrieving the mercurial info and appending it to the version number in the dox * dox: remove the old example list * fix the option to build a binary library, although it's not very useful and will be removed * add basic .hgignore file and script to build the docs (thanks to Thomas Capricelli) ## [2.0.4] Released August 1, 2009 Changes since 2.0.3: * Several fixes in the overloaded new and delete operators. Thanks to Hauke Heibel. * compilation fix: add the missing `ei_atan2` function. Thanks to Manuel Yguel. * Use `ei_atan2` instead of using `std::atan2` directly. * several compilation fixes in the Qt interoperability code: methods `toQTransform()` and `toQMatrix()`. Thanks to Anthony Truchet. * compilation fix and simplification in Matrix assignment * compilation fixes in `a *= b` and `a = a*b` when a has to be resized. * remove a "stupid" version of `ei_pow`. for integers for gcc >= 4.3 * bug fix in `Quaternion::setFromTwoVectors()` * several ctest improvements: use our own dashboard, use a separate project for the 2.0 branch. * documentation: improvement on the pages on unaligned arrays (the online copies have been updated immediately). ## [2.0.3] Released June 21, 2009 Changes since 2.0.2: * precision and reliability fixes in various algorithms, especially LLT, QR, Tridiagonalization, and also a precision improvement in LU. * fix LLT and LDLT solve() on uninitialized result (was causing an assertion). * add Eigen/Eigen and Eigen/Dense headers for convenience * document a newly found cause for the "unaligned array" assertion * backport documentation improvements on transpose() and adjoint() * updates in the Sparse module (was needed to support KDE 4.3) ## [2.0.2] Released May 22, 2009 Changes since 2.0.1: * Fix `linearRegression()` compilation, actually it is reimplemented using the better fitHyperplane() which does total least-squares. * Add missing `setZero()` etc... variants taking size parameters and resizing. These were mentioned in the tutorial but weren't implemented. * Fix `posix_memalign` platform check. This fixes portability issues. Thanks to Ross Smith. * Fix detection of SSE2 on the Windows 64-bit platform. * Fix compatibility with the old GCC 3.3: it is now fully supported again. * Fix warnings with recent GCC (4.4.0 and 4.3.3). ## [2.0.1] Released April 14, 2009 Changes since 2.0.0: * disable alignment altogether on exotic platforms on which we don't vectorize anyway. This allows e.g. to use Eigen on ARM platforms. * new StdVector header with a new workaround for the problems with std::vector. * workarounds for MSVC internal compiler errors * MSVC 9 compilation fix (patch by Hauke Heibel) * fixes for various bugs in Maps/Blocks that could give wrong results * fix bug in 4x4 matrix inverse that could give wrong results * compilation fix in SliceVectorization * fix wrong static assertion (patch by Markus Moll) * add missing operators in `aligned_allocator` (thanks to Hauke Heibel) ## [2.0.0] Released February 2, 2009