Eigen on Eigen: A C++ template library for linear algebra

Note we have switched to semantic versioning, so have dropped the “World” version 3 from the version number. Previously, Eigen used a WORLD.MAJOR.MINOR scheme. From now on, version numbers will follow the MAJOR.MINOR.PATCH format, indicating breaking changes, new features, and bug fixes, respectively. The WORLD version will remain 3 for this and subsequent releases for posterity.

Eigen 3.4.1 released!

Tue, 30 Sep 2025 21:36:27 +0000

Eigen 3.4.1 has been released on September 30, 2025.

Please check the release page for source archives and release notes.

Eigen 5.0

Tue, 30 Sep 2025 15:26:52 +0000

Eigen 5.0.0 was released on September 30 2025. It can be downloaded from Gitlab.

Summary

Eigen 5.0 provides many new features, performance enhancements, and bugfixes throughout Eigen’s core template expression infrastructure and linear algebra facilities. The full set of changes and related issues are too large to list here, but can be accessed via the release milestone %5.0.

This is the last major release to support the C++14 language standard. The master branch and subsequent releases will require support for C++17.

Developer's Corner

Mon, 17 Apr 2023 16:21:29 +0000

Communication between developers

Most discussion happens on Discord or on specific GitLab issues.

Contributors crediting and copyright

Everyone who made even the smallest contibution should add himself/herself to the Credits.

Everyone keeps copyright on his contributions. There is no copyright assignment.

When making a contribution on behalf of your employer, please try making it in your own name, not in your employer’s name, if possible.

When you make large improvements to a source file, it is a good idea to add yourself a copyright line in it, although this is by no means necessary: you do implictly get copyright on the code you wrote.

FAQ

Tue, 04 Oct 2022 17:28:38 +0000

Licensing

Since the 3.1.1 release, Eigen is licensed under the MPL2. We refer to the MPL2 FAQ for initial questions.

Eigen and other libraries

Should I use Eigen?

Probably, but check pit falls first.

Why another matrix library? What is the need for Eigen?

First of all, see the Overview. No other library provides all of the features and benefits listed there.

The Eigen project started when some hackers from the large KDE meta-project realized the need for a single unified matrix library.

Working notes - Tensor module

Fri, 07 Jan 2022 14:20:04 +0000

See also: Tensor support for a general introduction

IMPORTANT: A lot of the stuff on this page is now obsolete, due to work by Benoit Steiner. This page will be updated soon.

General TODO list

Let’s start with a general TODO / wishlist, and some things might be very difficult to implement, so the first goal would be to start with the lower-hanging fruit on this list.

test the whole thing with different compilers (MSVC etc.) and fix potential compatibility problems in this regard
simple expressions such as adding / subtracting two tensors and scalar multiplication
subtensors / generalized blocks
TensorMap analogous to Map
Ref or (if that’s not possible) TensorRef
reshaping (analogous to the to-be-implemented version in matrices)
.asMatrix() for tensors (or tensor expressions) with two indices
.asVector() for tensors (or tensor expressions) with one index
similarly, somehow implement a .asTensor() expression for the standard matrices/vectors/array (if we can do that in a way that doesn’t force people to use a C++11 compiler if they don’t want to use tensors…)
tensor “arrays”, so that element-wise multiplication (or sine or …) is possible
efficient full and partial transpositions (full transposition: reverse order of all indices, partial: reverse only a few of them)
contractions
tensor product of two matrices that generates a tensor of rank 4
generic expressions with index placeholders, such has result(_1, _2, _3) = tensor1(_1, _, _) * tensor2(_, _2, _3) or similar (need to define a nice API for this)
- in that vein, use efficient GEMM kernels for this when possible (might actually make sense to first partially transpose, then use GEMM kernel and then partially transpose back for some expressions, but not for others -> need some way of determining cost of these expressions)
nice user interface to write loops over multiple indices (don’t have to write 5 for-loops)
comma-initializer for tensors? if tensor has 4 indices, how do we handle this?
fixed-size tensors
sparse tensors

Class Hierarchy

Currently, there is no class hierarchy, and the Tensor class template only stores values. Ideally, we want to have a class hierarchy in the same way the rest of Eigen does, because people have put in a lot of thought into that.

Contributing to Eigen

Wed, 27 Oct 2021 16:39:45 +0000

Eigen is written and maintained by volunteers. If you are willing to help, great! Here are some pointers to get you started.

Support

Perhaps the easiest way to help is to be willing to support new (and not so new) users of Eigen and answer their questions. People ask questions on the StackOverflow, or Discord. You can also improve our FAQ with questions (and answers) that arise frequently.

Users arrive with different levels of C++ and mathematics knowledge, so whatever your level of experience, you can help out with this. Do not be too worried about given wrong advice; if you are not sure that your answer is correct, just say you are not sure and others will jump in if necessary.

Reforking the GitLab Project

Fri, 15 Oct 2021 16:44:58 +0000

Due to an incident that occurred on October 2, 2021, all GitLab fork relationships to the main Eigen project created before that date have been severed. This will prevent users from creating new MRs from these severed forks, and from reopening old ones.

Fortunately, there is a way via the GitLab API to re-establish the fork connection.

Create a personal access token (documentation)
- Navigate to https://gitlab.com/-/user_settings/personal_access_tokens?name=refork&scopes=api,read_user
- Click the button: Create personal access token
- Copy the token at the top of the screen.
Determine your local project’s ID.
- Navigate to your fork’s main page (e.g. https://gitlab.com/cantonios/eigen)
- Note the project ID number directly under the project name (e.g. 17989470)
Use the GitLab REST API to delete the existing broken fork relationship, and re-add it.

Bash:

Eigen 3.4

Thu, 14 Oct 2021 15:26:52 +0000

Eigen 3.4 was released on August 18 2021. It can be downloaded from the Download section on the Main Page or from Gitlab.

Notice: that 3.4.x will be the last major release series of Eigen that will support c++03. The master branch will drop c++03 support after this release.

Changes to supported modules

Changes that might break existing code

Using float or double for indexing matrices, vectors and arrays will now fail to compile, ex.:

MatrixXd A(10,10);
float one = 1;
double a11 = A(one,1.); // compilation error here

New Major Features in Core

Add c++11 initializer_list constructors to Matrix and Array [doc]:

MatrixXi a {      // construct a 2x3 matrix
      {1,2,3},    // first row
      {4,5,6}     // second row
};
VectorXd v{{1, 2, 3, 4, 5}};    // construct a dynamic-size vector with 5 elements
Array<int,1,5> a{1,2, 3, 4, 5}; // initialize a fixed-size 1D array of size 5.

Add STL-compatible iterators for dense expressions [doc]. Some examples:

VectorXd v = ...;
MatrixXd A = ...;
// range for loop over all entries of v then A
for(auto x : v) { cout << x << " "; }
for(auto x : A.reshaped()) { cout << x << " "; }
// sort v then each column of A
std::sort(v.begin(), v.end());
for(auto c : A.colwise())
    std::sort(c.begin(), c.end());

New versatile API for sub-matrices, slices, and indexed views [doc]. It basically extends A(.,.) to let it accept anything that looks-like a sequence of indices with random access. To make it usable this new feature comes with new symbols: Eigen::indexing::all, Eigen::indexing::last, and functions generating arithmetic sequences: Eigen::seq(first,last[,incr]), Eigen::seqN(first,size[,incr]), Eigen::lastN(size[,incr]). Here is an example picking even rows but the first and last ones, and a subset of indexed columns:

MatrixXd A = ...;
std::vector<int> col_ind{7,3,4,3};
MatrixXd B = A(seq(2,last-2,fix<2>), col_ind);

Add C++11 template aliases for Matrix, Vector, and Array of common sizes, including generic Vector<Type,Size> and RowVector<Type,Size> aliases [doc].

MatrixX<double> M;  // Instead of MatrixXd or Matrix<Dynamic, Dynamic, double>
Vector4<MyType> V;  // Instead of Vector<4, MyType>

New support for bfloat16. The 16-bit Brain floating point format is now available as Eigen::bfloat16. The constructor must be called explicitly, but it can otherwise be used as any other scalar type. To convert back-and-forth between uint16_t to extract the bit representation, use Eigen::numext::bit_cast.

  bfloat16 s(0.25);                                 // explicit construction
  uint16_t s_bits = numext::bit_cast<uint16_t>(s);  // bit representation
  
  using MatrixBf16 = Matrix<bfloat16, Dynamic, Dynamic>;
  MatrixBf16 X = s * MatrixBf16::Random(3, 3);

New backends

Arm SVE: Eigen now supports Arm’s Scalable Vector Extension (SVE). Currently only fixed-length SVE vectors for uint32_t and float are available.
MIPS MSA: Eigen now supports the MIPS SIMD Architecture (MSA)
AMD ROCm/HIP: Eigen now contains a generic GPU backend that unifies support for NVIDIA/CUDA and AMD/HIP.
Power 10 MMA Backend: Eigen now has initial support for Power 10 matrix multiplication assist instructions for float32 and float64, real and complex.

Improvements to Eigen Core

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

  #include <Eigen/SVD>
  MatrixXf m = MatrixXf::Random(3,2);
  JacobiSVD<MatrixXf> svd(m, ComputeThinU | ComputeThinV);
  if (svd.info() == ComputationInfo::Success) {
    // SVD computation was successful.
    VectorXf x = svd.solve(b);
  }

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.

  SparseMatrix<float> A(10, 10);
  VectorXf x = VectorXf::Random(10);
  A = x.asDiagonal();
  A += x.asDiagonal();

Support added for SuiteSparse KLU routines via the KLUSupport module. SuiteSparse must be installed to use this module.

  #include <Eigen/KLUSupport>
  A.makeCompressed();   // Recommendation is to compress input before calling sparse solvers.
  KLU<SparseMatrix<T> > klu(A);
  if (klu.info() == ComputationInfo::Success) {
    VectorXf x = klu.solve(b);
  }

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

Improved Geometry Module

Behavioral change: Transform::computeRotationScaling() and Transform::computeScalingRotation() are now more continuous across degeneracies (see !349).
New partial vectorization support added for Quaternion.
Generic vectorized 4x4 matrix inversion.

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

  MatrixXf A(10, 5);               // 10x5  matrix.
  A.setConstant(NoChange, 10, 2);  // 10x10 matrix of 2s.
  A.setConstant(5, NoChange, 3);   //  5x10 matrix of 3s.
  A.setZero(NoChange, 20);         //  5x20 matrix of 0s.
  A.setZero(20, NoChange);         // 20x20 matrix of 0s.
  A.setOnes(NoChange, 5);          // 20x5  matrix of 1s.
  A.setOnes(5, NoChange);          //  5x5  matrix of 1s.
  A.setRandom(NoChange, 10);       //  5x10 random matrix.
  A.setRandom(10, NoChange);       // 10x10 random matrix.

Added setUnit(Index i) for vectors that sets the i th coefficient to one and all others to zero.

  VectorXf v(5);
  v.setUnit(3);   // { 0, 0, 0, 1, 0}

Added transpose(), adjoint(), conjugate() methods to SelfAdjointView.
Added shiftLeft() and shiftRight() coefficient-wise arithmetic shift functions to Arrays.

  ArrayXXi A = ArrayXXi::Random(2, 3);
  ArrayXXi B = A.shiftRight<2>();
  ArrayXXi C = A.shiftLeft<6>();

Enabled adding and subtracting of diagonal expressions.

  VectorXf x = VectorXf::Random(5);
  VectorXf y = VectorXf::Random(5);
  MatrixXf A = MatrixXf::Identity(5, 5);
  A += x.asDiagonal() - y.asDiagonal();

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. Example for max:

// Elementwise maximum
Eigen::MatrixXf left, right, r0, r1, r2;
r0 = left.cwiseMax(right); // Implementation defined behavior.
// Propagate NaN if either argument is NaN.
r1 = left.template cwiseMax<PropagateNaN>(right);
// Suppress NaN if at least one argument is not a NaN.
r2 = left.template cwiseMax<PropagateNumbers>(right);

// Max reductions
Eigen::MatrixXf m;
float nan_or_max = m.maxCoeff(); // Implementation defined behavior.
float nan_if_any_or_max = m.template maxCoeff<PropagateNaN>();
float nan_if_all_or_max = m.template maxCoeff<PropagateNumbers>();

Changes to unsupported modules

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. Example:

  #include <Eigen/CXX11/ThreadPool>

  const int num_threads = 42;
  Eigen::ThreadPool tp(num_threads);
  auto do_stuff = []() { ... };
  tp.Schedule(do_stuff);

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. Example:

// This example applies std::sqrt to all output elements from a tensor contraction. 
// The optional OutputKernel argument to the contraction in this example is a functor over a 
// 2-dimensional buffer. The functor is called once for each output block of the contraction 
// result, to perform the elementwise sqrt operation while the block is hot in cache.
struct SqrtOutputKernel {
  template <typename Index, typename Scalar>
  EIGEN_ALWAYS_INLINE void operator()(
      const internal::blas_data_mapper<Scalar, Index, ColMajor>& output_mapper,
      const TensorContractionParams&, Index, Index, Index num_rows,
      Index num_cols) const {
    for (int i = 0; i < num_rows; ++i) {
      for (int j = 0; j < num_cols; ++j) {
        output_mapper(i, j) = std::sqrt(output_mapper(i, j));
      }
    }
  }
};

Tensor<float, 4, DataLayout> left(30, 50, 8, 31);
Tensor<float, 5, DataLayout> right(8, 31, 7, 20, 10);
Tensor<float, 5, DataLayout> result(30, 50, 7, 20, 10);
Eigen::array<DimPair, 2> dims({{DimPair(2, 0), DimPair(3, 1)}});

result = left.contract(right, dims, SqrtOutputKernel());

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. Example:

  Tensor<float, 3> in1(200, 30, 70);
  Tensor<float, 3> in2(200, 30, 70);
  Tensor<float, 3> out(200, 30, 70);

  Eigen::ThreadPool tp(internal::random<int>(3, 11));
  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));

  Eigen::Barrier b(1);
  auto done = [&b]() { b.Notify(); };
  out.device(thread_pool_device, std::move(done)) = in1 + in2 * 3.14f;
  b.Wait();

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.

Improvements to FFT module

Faster and more accurate twiddle factor computation.

Improvements to EulerAngles

EulerAngles can now be directly constructed from 3D vectors
EulerAngles now provide isApprox() and cast() functions

Changes to sparse iterative solvers

Added new IDRS iterative linear solver.

  #include <unsupported/Eigen/IterativeSolvers>
  A.makeCompressed();   // Recommendation is to compress input before calling sparse solvers.
  IDRS<SparseMatrix<float>, DiagonalPreconditioner<float> > idrs(A);
  VectorXf x = idrs.solve(b);
  bool success = (idrs.info() == ComputationInfo::Success);

Improvements to Polynomials

PolynomialSolver can now be used with complex numbers
The solver will automatically choose between EigenSolver and ComplexEigenSolver depending on the scalar type used

Other relevant changes

Eigen now provides an option to test with an external BLAS library
Eigen can now be used with the PGI Compiler
Printing when using GDB has been improved
Eigen can now detect if a platform supports int128 intrinsics

Testing

The full Eigen test suite was built and run successfully (in c++03 and c++11 mode) with the following compiler/platform/OS combinations:

User:Tellenbach

Mon, 30 Aug 2021 19:34:58 +0000

Eigen 3.4.0 released!

Wed, 18 Aug 2021 21:36:27 +0000

Eigen 3.4.0 has been released on August 18, 2021.

Notice: that 3.4.x will be the last major release series of Eigen that will support c++03. The master branch will drop c++03 support after this release.

The source archive is available at: https://gitlab.com/libeigen/eigen/-/releases/3.4.0

Please check the release page for a list of changes.

User:Everton

Tue, 17 Aug 2021 22:29:41 +0000

New Power 10 MMA Backend

Initial support for Power 10 matrix multiplication assist instructions for float32, float64 real and complex.

Altivec/Power improvements

General performance improvement and bugfixes.
Enhanced vectorization of current 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.

Eigen 3.4-rc1 released!

Mon, 19 Apr 2021 11:16:50 +0000

Eigen 3.4-rc1 has been released on April 19, 2021.

Depending on the amount of reported issues, 3.4 will be released late April or early May.

The source archive is available at: https://gitlab.com/libeigen/eigen/-/releases/3.4-rc1

Please check the release page for a list of changes.

Tests

Sun, 18 Apr 2021 16:02:34 +0000

Prerequisites

First of all, this page applies to the development branch.

You need to know how to use CMake, see our page on that topic.

From now on, we assume that we are in the build directory and that you have already run cmake. There is no need to pass a particular option to CMake to enable tests.

Building and running unit tests

To build and run all tests using CTest, use the check target. For example, if your platform uses make:

Benchmark

Sun, 04 Apr 2021 17:48:40 +0000

This page is rather out of date. Please help us to generate and maintain up-to-date benchmarks.

See also the performance monitoring page for benchmark of Eigen along time.

The following benchmark results have been generated using a (heavily) modified version of the Benchmark for Templated Libraries (BTL) from Laurent Plagne. Our modified version can be found in the git repository under bench/btl. We did our best to make the best use of each library, however, any hints on making a lib working better are welcome. All libs have been configured to use dynamic-size column-major matrices and only one thread. Try it yourself.

Git

Sat, 27 Feb 2021 22:59:33 +0000

Git is the source-control management (SCM) tool that we use for Eigen. This page is not intended to be a Git tutorial but a brief wrap-up on how we use Git for Eigen.

GitLab Workflow

Eigen’s sources are hosted on GitLab where we use a fast-forward merge and squash policy.

If you plan to contribute a patch to Eigen you have to follow our GitLab workflow:

Fork the official Eigen repository.
Clone your fork.
Create a new feature branch.
Make your changes and commit them.
Create a merge request. The title and description of your merge request will be the commit message once the request gets merged so make sure to add a descriptive and condensed title and an informative and clear description. Please make sure to enable the option “Allow commits from members who can merge to the target branch.” to enable maintainers to rebase your branch.

Keep your fork in sync

If you plan to contribute to Eigen more than once, it’s necessary to synchronize it with the official Eigen repository. This can be done using plain Git by adding the official repository as a second remote. You can then rebase to it.

Eigen 3.3.9 released!

Fri, 04 Dec 2020 22:09:00 +0000

Eigen 3.3.9 has been released on December 4, 2020.

This is a maintenance release fixing minor bugs and compilation issues. For more details have a look at the changelog.

The sources are available at https://gitlab.com/libeigen/eigen/-/releases/3.3.9.

Eigen on Discord

Mon, 16 Nov 2020 17:19:05 +0000

Join our Discord server to discuss Eigen-related topics with other users and developers.

Eigen 3.3.8 released!

Mon, 05 Oct 2020 12:13:08 +0000

Eigen 3.3.8 has been released on October 5, 2020.

This is a maintenance release fixing minor bugs and compilation issues. For more details have a look at the changelog.

The sources are available at https://gitlab.com/libeigen/eigen/-/releases/3.3.8.

Eigen is now on GitLab.com

Thu, 30 Jul 2020 14:47:56 +0000

Since the end of 2019, Eigen’s repository and bugtracker are now both hosted on GitLab.com, meaning that Eigen is now using git for source code management.

The old mercurial repository is still readable on bitbucket.org, but it is not synchronized with the git repository, meaning that it should be used for archive purposes only. The same remark applies for the old bugzilla instance.

Migration to GitLab.com scheduled on the December 4th

Mon, 25 Nov 2019 20:41:17 +0000

Following the decision of Bitbucket.org to delete all mercurial repositories next spring, we decided to migrate to a git repository hosted on gitlab.com. We also decided to take this opportunity to migrate our self hosted bugzilla instance to gitlab.com. Both migrations are scheduled on the 4th of December, starting at 8:00 UTC, and the new project:
https://gitlab.com/libeigen/eigen
will be made public once the migration is completed.

Details on the migration process:

Our bugzilla will be made read only; all entries, comments and attachments will be transferred to gitlab.com while keeping the same bug IDs.
https://bitbucket.org/eigen/eigen will be unavailable and replaced by an empty project pointing to https://gitlab.com/libeigen/eigen
The old mercurial repository will still be readable on eigen.tuxfamily.org but with no updates.
Existing pull-requests will be archived as static pages hosted on eigen.tuxfamily.org
The official git mirror (https://github.com/eigenteam/eigen-git-mirror) will be kept as it is for a few months with no updates until we eventually replace it by an empty project pointing to https://gitlab.com/libeigen/eigen. (it cannot be synchronised because of hash differences)

Performance monitoring

Fri, 18 Jan 2019 08:54:23 +0000

You can follow the performance of Eigen along its development there:

Run those tests on your own computer

Generating those graph for your own computer and compiler flags is fairly easy. From Eigen’s sources, make a copy of script/eigen_monitor_perf.sh to some location, adjust the different variables to match your setup, update the rsync and ssh lines if you want to upload the graph to your own server (or comment them if you don’t want to share your results), and then run the script. That’s all. The charts are generated in $EIGEN_SOURCE_PATH/bench/perf_monitoring/$PREFIX/.

Eigen 3.3.7 released!

Tue, 11 Dec 2018 19:24:35 +0000

Eigen 3.3.7 has been released on December 11, 2018.

This is a maintenance release fixing a compilation issue introduced in the previous 3.3.6 release. The compilation issue only occurred for some versions of GCC with compiler optimization turned off.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.3.7/eigen-3.3.7.tar.bz2 .

Eigen 3.3.6 released!

Mon, 10 Dec 2018 13:50:59 +0000

Eigen 3.3.6 has been released on December 10, 2018.

This is a maintenance release fixing several minor bugs and compilations issues. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.3.6/eigen-3.3.6.tar.bz2 .

We plan a beta1 release of the next Eigen 3.4 within the next few days, stay tuned!

Reliability

Mon, 15 Oct 2018 12:49:28 +0000

Choice of algorithms

“The Fast drives out the Slow even if the Fast is wrong.” — W. Kahan

Any matrix library has to make trade-offs between speed and reliability. Eigen’s bias is towards reliability. That may be related to the fact that its founder is a former non-applied mathematician.

As our table of decompositions shows, we have a bias towards safer, pivoting algorithms. Where applicable, we tend to provide both a partial-pivoting algorithm that offers a quite good speed/reliability trade-off, and a full-pivoting algorithm that’s entirely uncompromising on reliability. See for example FullPivLU.

Eigen 3.3.5 released!

Mon, 23 Jul 2018 09:36:30 +0000

Eigen 3.3.5 has been released on July 23, 2018.

This is a maintenance release fixing several minor bugs and compilations issues. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.3.5/eigen-3.3.5.tar.bz2 .

Eigen now offers a git mirror on github!

Fri, 29 Dec 2017 17:27:46 +0000

Git users can now clone Eigen through git or import it as submodule: https://github.com/eigenteam/eigen-git-mirror.

Eigen 3.3

Wed, 06 Sep 2017 09:56:42 +0000

Eigen 3.3 has been released on November 10, 2016. It can be downloaded from the Download section on the Main Page. Since Eigen 3.2, the 3.3 development branch received more than 3500 commits [1] representing numerous major changes.

Release history:

Eigen 3.3 alpha-1 was released on September 4, 2015. It includes about 1660 commits since 3.2. It includes all bug-fixes and improvements of the 3.2 branch up to the 3.2.5 version, as detailed in the respective change-logs: 3.2.1, 3.2.2, 3.2.3, 3.2.4, 3.2.5.
Eigen 3.3 beta-1 was released on December 16, 2015. It includes about 350 commits since 3.3 alpha1, as detailed in the respective change-log.
Eigen 3.3 beta-2 was released on July 26, 2016. It includes more that 1000 commits since 3.3 beta1, as detailed in the respective change-log.
Eigen 3.3 rc-1 was released on September 22, 2016. It includes more that 300 commits since 3.3 beta2, as detailed in the respective change-log.
Eigen 3.3 rc-2 was released on November 04, 2016. It includes more that 90 commits since 3.3 rc1, as detailed in the respective change-log.

The major changes since 3.2 are summarized below.

Eigen 3.3.4 released!

Thu, 15 Jun 2017 07:11:31 +0000

Eigen 3.3.4 has been released on June 15, 2017.

This is a maintenance release fixing a few regressions and other issues. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.3.4/eigen-3.3.4.tar.bz2 .

Eigen 3.3.3 released!

Tue, 21 Feb 2017 13:40:28 +0000

Eigen 3.3.3 has been released on February 21, 2017.

This is a maintenance release fixing a few regressions and other issues. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.3.3/eigen-3.3.3.tar.bz2 .

Eigen 3.3.2 released!

Wed, 18 Jan 2017 14:12:31 +0000

Eigen 3.3.2 has been released on January 18, 2017.

This is a maintenance release with few fixes of compilation and performance regressions, some doxygen documentation improvements, and the addition of transpose, adjoint, conjugate methods to SelfAdjointView to ease writing generic code. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.3.2/eigen-3.3.2.tar.bz2 .

Working notes - Indexing++

Sun, 08 Jan 2017 14:00:33 +0000

The goal of this page is to summarize the different ideas and working plan to (finally!) provide support for flexible row/column indexing in Eigen. See this bug report.

Needs

We aim to support various indexing mechanisms. For each dimension, we would like to be able to have any of:

all: as in A(:)
singleton: as in A(3) (already supported!)
index-array: as in A([3 1 5])
range-based: as in A(3:9), but sometimes it is also convenient to specify the start+length similar to what Eigen::Block offers.
slicing: as in A(3:2:9). Same as for range, we sometime also want to specify start+length+stride
negative indices: as in A(end-3) or A(3:2:end-1)
boolean masking: as in A(A>0)

All of this with a concise and unambiguous API! We should also be able to provide compile-time information such as lengths and maybe strides.

Info about 3.0

Wed, 21 Dec 2016 13:57:49 +0000

This page was written in November 2009 in the run-up to Eigen 3.0 and has not been kept up-to-date when Eigen 3.0 was released. It is kept for historical reasons.

What is Eigen 3.0?

Eigen 3.0 has been released on March 19, 2011. It is not API or ABI compatible with Eigen 2.0, whence the version number increase to 3.0. However, porting to 3.0 is relatively easy and Eigen 3.0 is co-installable with Eigen 2.0. We also provide extensive porting documentation.

Todo for 3.0

Wed, 21 Dec 2016 13:54:41 +0000

Eigen_Owl_Todo.jpg

This page is deprecated. The new way of tracking the 3.0 release is using the tracking bug on Bugzilla.

This Todo is to keep track of the things that must be done for Eigen 3.0. There is a separate Todo for long-term and generalist Todo items, not specifically for 3.0. There is also a separate page tracking the status of unsupported modules.

Note that a ton of stuff has already been done, and isn’t mentioned here, so this page isn’t at all intend to give an idea of all of what there will be in 3.0.

Status of unsupported modules

Wed, 21 Dec 2016 13:49:52 +0000

This page gives the status of the modules under unsupported/. Those module are work in progress, they often lack features, tests or documentation, and their API can change at any time.

Name	Contact	Code status	Tests status	Documentation status	Date of start
Adolc forward module	Gael	This module only support the forward mode of adolc. It has now been superseded by our own AutoDiff module.	?	?	February 2009
Aligned vector3 module	Gael	Pretty much complete.	Could be improved a bit.	Could be improved a bit.	May 2009
Auto Diff module	Gael	Need some refactoring.	?	None	April 2009
BVH module	Baran?	?	?	Yes	March 2009
Complex module	Mark	proof-of-concept code to verify that it is possible to make the result of operator& be castable to either Eigen::Complex or std::complex	Minimal	No	June 2009
Fast Fourier Transform module	Mark	functional for 1-D cases with FFTW or KISSFFT backend.Some of the interface may still change. TODO: 2-D FFTs & Intel MKL backend	Tests exist to test forward,inverse FFTs with sizes with various factors of 2s,3s,and 5s. float, double, long double are tested. FFTW backend is tested.	No	May 2009
Iterative solvers module	Gael	This module was only for Step. It need to be completely rewritten.	?	Few	February 2009
Matrix functions module	Jitse Niesen	Contains implementations for matrix exponential and other entire functions. Ready to switch to supported, as far as I (Jitse) am concerned. Matrix logarithm is missing.	OK. One failing test, due to issues in Eigen core with 1×1 matrices (Benoît is working on this).	Usable, but can be improved.	May 2009
More vectorization module	Rohit?	?	?	None	April 2009
Nonlinear optimization module	Thomas Capricelli (orzel)	I think it doesn’t work yet with special matrices (Sparse…), though this is probably possible to achieve. The internal stuff still has and uses its own QR decompositions (both Givens and Householder). I’m waiting for the QR API to settle in Eigen (availability of Givens decomposition and stable API). The API should probably be factorized with other parts of Eigen, typically Iterative solvers.	I think there are enough tests.	Minimalist documentation is here.	September 10th, 2009
Numerical differentiation module	Thomas Capricelli (orzel)	I don’t expect to add any more feature or to change the API.	There are few tests, could probably use more.	Minimalist documentation is here, should be enhanced before switching to supported status.	August 10th, 2009
Skyline module	kayhman?	?	?	Some	November 2009

Visual Studio

Wed, 21 Dec 2016 13:37:48 +0000

Moved to IDE/Visual Studio.

IDEs

Wed, 21 Dec 2016 13:36:15 +0000

Some workarounds and hacks might be useful for IDEs in order to use Eigen in an optimal way. This page is meant to collect them, to help newcomers.

Eclipse CDT

Paths

Apart from “Organize includes” (see the section below), everything works out of the box. For example, if Eigen is installed in /usr/include/eigen3 and this path is added to the Project Properties > C/C++ General > Paths & Symbols > Includes > GNU C++, you only need to add includes of the form

Eigen 3.3.1 released!

Tue, 06 Dec 2016 10:48:23 +0000

Eigen 3.3.1 has been released on December 06, 2016.

This is a maintenance release with few bug fixes and performance regressions since the first release of the 3.3 series. This release also includes better cmake support (imported targets, relocatable package). For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.3.1/eigen-3.3.1.tar.bz2 .

Eigen 3.3 released!

Thu, 10 Nov 2016 13:17:36 +0000

After more than three years of efforts, Eigen 3.3 has been released on November 10, 2016.

Since Eigen 3.2, the 3.3 version leverage numerous major novel features and improvements that are summarized in the dedicated 3.3 release page.

Those include, a novel evaluation mechanism of expressions, support for AVX, FMA, AVX512, VSX and ZVector vector instructions, unaligned vectorization, nvcc/CUDA, more OpenMP parallelism, a fast divide and conquer SVD algorithm, a CompleteOrthogonalDecomposition class for fast minimal norm solving, a LS-CG solver, a fast reciprocal condition number estimators in LU and Cholesky factorizations, LU::transpose()/adjoint() API, support for inplace decompositions, support for matrix-free iterative solvers, new array functions, support for any BLAS/LAPACK libraries as backend, improved support for mixing scalar types, eigenvectors in GeneralizedEigenSolver, a complete rewrite of LinSpaced, a non officially supported but massively used Tensor module with CUDA and OpenCL support, and more.

Eigen 3.3-alpha1 released!

Thu, 10 Nov 2016 12:43:20 +0000

Eigen 3.3-alpha1 has been released on September 4, 2015.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.3-alpha1/eigen-3.3-alpha1.tar.bz2

This alpha version introduces a novel evaluation mechanism of expressions, as well as numerous exciting features such as fast divide and conquer SVD, support for AVX and VSX vector instructions, more OpenMP parallelism, a LS-CG solver, and more. Check the page dedicated on the 3.3 release for a comprehensive review of the novelties and improvements.

As for any alpha and beta release, everybody is invited to test this release on their own basecode and report any compilation issue or performance regression on the bugtracker.

Eigen 3.3-rc2 released!

Fri, 04 Nov 2016 08:13:40 +0000

Eigen 3.3-rc2 has been released on November 4, 2016.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.3-rc2/eigen-3.3-rc2.tar.bz2

Since 3.3-rc1, this release introduces support for AVX512 and a complete rewrite of LinSpaced to leverage more numerical robustness and consistencies for real and integer scalar types. It also includes a few regression fixes and documentation improvements.

Complete changelog.

Tensor support

Mon, 24 Oct 2016 15:49:06 +0000

IMPORTANT NOTE: The current developement version of Eigen (post-3.2) supports Tensors. This support is experimental and a moving target.

For a TODO list / discussion on further features, see Working notes - Tensor module.

Requirements

Since using objects with an (in principle) arbitrary number of indices requires variadic templates, Eigen’s tensor module requires C++11. The initial version of the Tensor module has been tested with g++ from 4.6 as well as clang 3.2 and 3.3. Intel’s 13.1 compiler also works in principle (13.0 crashes during compilation), but produces non-optimal code. For these compilers, please supply at least -std=c++0x, -std=c++11 or even -std=c++1y to the compiler as a flag so that they switch to C++11/C++14 mode.

Eigen 3.2.10 released!

Tue, 04 Oct 2016 07:27:41 +0000

Eigen 3.2.10 has been released on October 4, 2016.

This is a maintenance release with few bug fixes and backports since the release of 3.2.9 two months ago. For more details, look at the Changelog.

Eigen 3.3 will be released very soon, and we encourage everybody to already move to 3.3-rc1.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.10/eigen-3.2.10.tar.bz2 .

Eigen 3.3-rc1 released!

Thu, 22 Sep 2016 20:47:13 +0000

Eigen 3.3-rc1 has been released on September 22, 2016.

If everything goes well, this release candidate should be last milestone before we release Eigen 3.3 next week.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.3-rc1/eigen-3.3-rc1.tar.bz2

Since 3.3-beta2, this release introduces a few new features including eigenvectors in GeneralizedEigenSolver, SparseMatrix::coeffs(), improved supports for custom nullary functors and custom complex types. This release also contains numerous fixes of all kinds and some documentation improvements.

Complete changelog.

Eigen3.3-beta2 released!

Tue, 26 Jul 2016 21:59:36 +0000

Eigen 3.3-beta2 has been released on July 26, 2016.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.3-beta2/eigen-3.3-beta2.tar.bz2

Since the previous 3.3-beta1 release, this beta version received more than 1000 commits including numerous fixes, some performance and numerical robustness improvements, as well as some key novel features such as the new CompleteOrthogonalDecomposition class for fast minimal norm solving, fast reciprocal condition number estimators in LU and Cholesky factorizations, support for inplace decompositions, unaligned vectorization, support for the new ZVector SIMD engine, support for any BLAS/LAPACK libraries as backend, improved support for mixing scalar types, and more.

Eigen 3.2.9 released!

Mon, 18 Jul 2016 14:31:13 +0000

Eigen 3.2.9 has been released on July 18, 2016.

This is a maintenance release with few bug fixes and backports since the release of 3.2.8 five months ago. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.9/eigen-3.2.9.tar.bz2 .

Eigen 3.2.8 released!

Tue, 16 Feb 2016 13:33:39 +0000

Eigen 3.2.8 has been released on February 16, 2016.

This is a maintenance release with few bug fixes and backports since the release of 3.2.7 three months ago. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.8/eigen-3.2.8.tar.bz2 .

Eigen3.3-beta1 released!

Wed, 16 Dec 2015 20:51:42 +0000

Eigen 3.3-beta1 has been released on December 16, 2015.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.3-beta1/eigen-3.3-beta1.tar.bz2

Since the previous 3.3-alpha1 release, this beta version introduces several fixes, as well as some novel features such as new array functions (rsqrt, sign, lgamma, erf, erfc), row/column-wise lpNorm, LU::transpose()/adjoint() API, support for matrix-free iterative solvers, improved sparse matrix filling and products, and more.

If you missed the major novelties introduced in the 3.3-alpha1 version, here is a brief summary of the most exciting ones: novel expression template engine, fast divide and conquer SVD, support for AVX and VSX vector instructions, more OpenMP parallelism, a LS-CG solver.

Eigen 3.2.7 released!

Thu, 05 Nov 2015 14:58:23 +0000

Eigen 3.2.7 has been released on November 5, 2015.

This is a maintenance release with few bug fixes and backports since the release of 3.2.6 one months ago. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.7/eigen-3.2.7.tar.bz2 .

Eigen 3.2.6 released!

Thu, 01 Oct 2015 07:08:58 +0000

Eigen 3.2.6 has been released on October 1, 2015.

This is a maintenance release with few bug fixes since the release of 3.2.5 three months ago. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.6/eigen-3.2.6.tar.bz2 .

Eigen3 Developer Documentation

Wed, 30 Sep 2015 09:01:25 +0000

Dense classes

This section can now be found in the doxygen-generated documentation; see

Nested Expression Templates

This section is completely outdated. It needs to be rewritten to match with Eigen 3.3 internals.

Example: MatrixXf A, B, C; C = A.transpose() + B;

A.transpose() returns an object of type Transpose where the MatrixXf A is nested into the Transpose expression. The nested type tells how to store the nested object. Here MatrixXf::Nested boils down to a MatrixXf&, and thus “A.transpose()” stores a reference to A.

Working notes - Expression evaluator

Wed, 02 Sep 2015 12:54:44 +0000

Goals

The goal here is to refactor our expression template mechanism so that the construction of the expression tree and its evaluation are 100% decoupled. Basically, at construction time, we should only assemble stupid *Expression* objects that only brings the proper API. Then, at evaluation time, via partial specialization, we would recursively create *Evaluator* objects reflecting how the considered sub-expressions can and have to be evaluated. In between we could then implement *TreeOptimizer* objects that would reorganize and optimize the expression tree through partial specialization.

Eigen 3.2.5 released!

Tue, 16 Jun 2015 10:59:54 +0000

Eigen 3.2.5 has been released on June 16, 2015.

This is a maintenance release with many bug fixes since the release of 3.2.4 five months ago. In particular, this release improves support for indefinite matrices in SimplicialLDLT, leverage several numerical improvements for 2x2 and 3x3 eigenvalue problems, ColPivHouseholderQR , RealSchur, etc. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.5/eigen-3.2.5.tar.bz2 .

Eigen 3.2.4 released!

Wed, 21 Jan 2015 22:56:26 +0000

Eigen 3.2.4 has been released on January 21st, 2015.

This is a maintenance release with a few bug fixes since the recent release of 3.2.3. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.4/eigen-3.2.4.tar.bz2 .

Eigen 3.2.3 released!

Tue, 16 Dec 2014 17:38:11 +0000

Eigen 3.2.3 has been released on December 16, 2014.

This is a maintenance release with many bug fixes since the release of 3.2.2 five months ago. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.3/eigen-3.2.3.tar.bz2 .

Eigen 3.2.2 released!

Mon, 04 Aug 2014 13:24:39 +0000

Eigen 3.2.2 has been released on August 4, 2014.

This is a maintenance release with many bug fixes since the release of 3.2.1 five months ago. In particular, this release includes various numerical improvements in JacobiSVD, LDLT, BiCGSTAB, and ColPivHouseholderQR. There are also some limited performance improvements and added functionality in the 3.2.2 release. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.2/eigen-3.2.2.tar.bz2 .

How to run the benchmark suite

Fri, 27 Jun 2014 15:08:17 +0000

Here are some notes explaining how to configure and run the benchmark suite.

Quick start guide

# create a working directory
$ mkdir build
$ cd build
# create the makefiles
$ cmake <path_to_eigen_source> -DCMAKE_BUILD_TYPE=Release -DEIGEN_BUILD_BTL=ON -DEIGEN3_INCLUDE_DIR=<path_to_eigen_source>
# compile the benchmarks
$ cd bench/btl
$ make -j4
# run the benchmark (on a single core)
# VERY IMPORTANT : logout, log into a console (ctrl+shift+F1) and shutdown your X server (e.g.: sudo init 3), and stop as most as services as you can
$ OMP_NUM_THREADS=1 ctest -V
# - go sleep -
# copy the results into the same directory
$ mkdir data/set1
$ cp libs/*/*.dat data/set1
# build the nice plots
$ cd data
$ ./go_mean set1/
# the plots (png and pdf files) are in set1/

Tips

BTL_CONFIG

BTL_CONFIG is an environment variable used to control some parameters:

How to contribute

Wed, 11 Jun 2014 16:19:36 +0000

REDIRECT Contributing to Eigen

Eigen 3.2.1 released!

Wed, 26 Feb 2014 16:57:25 +0000

Eigen 3.2.1 has been released on February 26, 2014.

This is a maintenance release with many bug fixes since the release of 3.2.0 half a year ago. The support for Eigen2 is now marked as deprecated and will be removed in the forthcoming 3.3 release. There are also some limited performance improvements and added functionality in the 3.2.1 release. For more details, look at the Changelog.

The source archive is at https://gitlab.com/libeigen/eigen/-/archive/3.2.1/eigen-3.2.1.tar.bz2 .

API Showcase

Sat, 10 Aug 2013 08:37:36 +0000

Here are some examples of Eigen 3’s API. Refer to the documentation for more details.

Performing row/column operations on a matrix

Let m be a matrix. All the following operations are allowed by Eigen, with the self-explanatory effect, and resulting in fully optimized code.

m.row(i) += alpha * m.row(j);
m.col(i) = alpha * m.col(j) + beta * m.col(k);
m.row(i).swap(m.row(j));
m.col(i) *= factor;

Operating on blocks inside a matrix or vector

m.block(firstRow, firstCol, rows, cols).setZero();
m.topLeftCorner(rows, cols) = some_other_matrix;
m.block<2,2>(firstRow, firstCol).setIdentity(); // optimized variant when the # of rows, cols are known at compile-time

There are also vector-specific operations. Let v be a vector.

Eigen 3.1.4 & 3.0.7 released!

Fri, 02 Aug 2013 19:32:31 +0000

Eigen 3.1.4 and 3.0.7 have been released on August 2, 2013.

The source archives are at: https://gitlab.com/libeigen/eigen/-/archive/3.1.4/eigen-3.1.4.tar.bz2, https://gitlab.com/libeigen/eigen/-/archive/3.0.7/eigen-3.0.7.tar.bz2.

Those are maintenance releases with various bug and warning fixes.

Complete changelogs: 3.1.4, 3.0.7

Eigen 3.2 released!

Wed, 24 Jul 2013 06:45:13 +0000

Eigen 3.2 has been released on July 24, 2013.

Since Eigen 3.1, the key new features of this version are: a built-in supernodal sparse LU solver adapted from SuperLU, a rank-revealing sparse QR factorization with numerical column pivoting, a RealQZ factorization, a GeneralizedEigenSolver, and a Ref<> class allowing to write non templated function taking various kind of Eigen dense objects without copies.

This release also includes a few new functions for dense and sparse matrices, built-in COLAMD ordering, support to SuiteSparse QR and Metis, as well as some accuracy and performance improvements.

Eigen 3.2-rc2 released!

Fri, 19 Jul 2013 15:03:36 +0000

Eigen 3.2-rc2 has been released on July 19, 2013.

This second release candidate fixes a naming collision by renaming the isFinite() function to allFinite, and an ICE with ICC 11.1.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.2-rc2/eigen-3.2-rc2.tar.bz2

Complete changelog.

Eigen 3.2-rc1 released!

Wed, 17 Jul 2013 09:42:34 +0000

Eigen 3.2-rc1 has been released on July 17, 2013.

This release candidate should be last milestone before we release Eigen 3.2 next week.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.2-rc1/eigen-3.2-rc1.tar.bz2

Since 3.2-beta1, this release introduces a few new features such: as isFinite and hasNaN reductions, vector-wise normalize and normalized functions, support for mixed static/dynamic sizes in .block(), sparse determinant computation through SparseLU, access to L and U factors in SparseLU, access to the Q factor in SparseQR, etc. Major fixes comprise significantly improved robustness of BiCGSTAB, and JacobiSVD::solve(), as well as many other fixes of all kinds.

Eigen received the SGP software award!

Fri, 05 Jul 2013 19:35:51 +0000

At the Symposium on Geometry Processing 2013, Eigen received the “High Quality Software in Geometry Processing Award 2013”. This award is sponsored by Geometry Factory.

Publications

Thu, 06 Jun 2013 20:55:00 +0000

Presentations

An overview of Eigen. First Plafrim scientific day. Bordeaux, May 31st, 2011. slides
Eigen: a c++ linear algebra library. Libraries for scientific computing. Ecole Polytechnique, May 15th, 2013. slides
Eigen tutorial @ Eurographics/CGLibs. Pisa, June 3rd, 2013. slides, demos.tgz
A three hour an half tutorial introducing Eigen in the context of computer graphics. Content:
- General introduction of Eigen,
- Design of Eigen: Expression templates, CRTP, Evaluators, Meta unroller, Cost model, SIMD, reductions,
- Use cases: space transformations, OpenGL, vectorization of 3D vectors, radial-basis-functions (dense linear regression), (bi-)harmonic interpolation on a 2D triangular mesh embedded in a 3D space (sparse matrices and solvers).
- Work-in-progress features (AVX, CUDA, SparseBlockMatrix).

Publications

Blog entries

Switch from IT++ to Eigen of GraphLab with some benchmarks 1

Eigen 3.1.3 released!

Tue, 16 Apr 2013 07:37:07 +0000

Eigen 3.1.3 has been released on April 16, 2013.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.3/eigen-3.1.3.tar.bz2

This is a maintenance release with various bug and warning fixes.

Complete changelog.

Eigen course at CG libs

Tue, 19 Mar 2013 16:35:44 +0000

A course on Eigen will be given at CG Libs: Smart Libraries for Computer Graphics, held in Pisa, June 3-5.

CG Libs is a great initiative organized by the Eurographics Italian chapter. Six open source libraries, including Eigen, will be deeply presented. Except SpiderGL that is written in javascript, all others use or has support for Eigen: vcglib, Point Cloud Library, ViennaCL, g2o, MeshLab.

Eigen 3.2.0-beta1 released!

Thu, 07 Mar 2013 08:32:16 +0000

Eigen 3.2.0-beta1 has been released on March 7, 2013.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.2-beta1/eigen-3.2-beta1.tar.bz2

This beta version introduces built-in LU and QR factorizations for sparse matrices, a real-QZ factorization and a generalized eigen solver for dense matrices, a new Ref<> class to ease writing generic but non-template functions taking Eigen objects as arguments, wrappers to the Metis and SuiteSparse QR libraries, as well as a couple of minor enhancements and bug fixes.

Complete changelog.

Eigen 3.0

Fri, 04 Jan 2013 09:45:05 +0000

Eigen 3.0 was released on March 19, 2011.

Eigen 3.1.2 released!

Mon, 05 Nov 2012 21:25:35 +0000

Eigen 3.1.2 has been released on November 5, 2012.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.2/eigen-3.1.2.tar.bz2

This is a maintenance release with various bug and warning fixes.

Complete changelog.

Eigen 3.1.1 released!

Sun, 22 Jul 2012 15:12:40 +0000

Eigen 3.1.1 has been released on July 22, 2012.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.1/eigen-3.1.1.tar.bz2

This is a maintenance release with various bug and warning fixes. It is particularly important as the first release under the MPL2 license.

Complete changelog.

Relicensed to MPL2!

Sun, 15 Jul 2012 15:53:18 +0000

Eigen has been relicensed to the MPL2!

See the official FAQ and the COPYING.README file.

If you’re interested in the background and motivation for this change, read the recent Eigen mailing list archives.

Licensing FAQ

Sun, 15 Jul 2012 14:46:03 +0000

This page used to have a long FAQ that we thought was useful when Eigen was LGPL-licensed.

Now that Eigen is MPL2-licensed, there is no need anymore for that. Common questions about the MPL2 are answered on the MPL2 FAQ. Do not hesitate ask on Discord if you have further questions, although we aren’t lawyers and you will be better served by asking directly the MPL2 specialists (see above MPL2 FAQ link).

Eigen 3.0.6 released!

Mon, 09 Jul 2012 16:38:23 +0000

Eigen 3.0.6 has been released on July 9, 2012.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.0.6/eigen-3.0.6.tar.bz2

This is a maintenance release with various bug and warning fixes.

Complete changelog.

Relicensing to MPL2!

Fri, 29 Jun 2012 15:45:23 +0000

We are in the process of relicensing to the MPL2 license.

See the official MPL2 FAQ.

Like the LGPL, the MPL2 is a weak-copyleft license. It is however a bit more liberal, as the copyleft does not propagate across source files. It’s a concept known as “file-level copyleft”.

The MPL2 is GPL-compatible and LGPL-compatible.

The MPL2 is 3x shorter than the LGPL+GPL (note that the LGPL is an addendum to the GPL) and is much, much easier to read and understand.

Eigen 3.1 released!

Sun, 24 Jun 2012 21:28:08 +0000

Eigen 3.1 has been released on June 24, 2012.

Since Eigen 3.0, this new version brings to live a set of officially supported sparse modules for the representation, assembly, and solving of sparse problems. This includes many built-in (Cholesky, CG, BiCGSTAB, ILU), and third-party (PaStiX, Cholmod, UmfPack, SuperLU, Pardiso) sparse linear solvers.

The second main novelty is the possibility to seamlessly fallback to Intel MKL for a couple of operations including matrix products (BLAS L2/L3), dense matrix decompositions (LAPACKE), and math array operations (via the Intel VML). These completely optional backends can be enabled through some compile-time preprocessor directives as explained in the respective manual page. Recall that Intel MKL is proprietary software (see this notice).

Eigen 3.1.0-rc2 released!

Thu, 21 Jun 2012 20:08:56 +0000

Eigen 3.1.0-rc2 has been released on June 21, 2012.

This second release candidate is due to a few late warning and minor bug fixes. The final release is thus delayed by a few days, and is planed for this week end.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.0/eigen-3.1.0-rc2.tar.bz2

Complete changelog.

Eigen 3.1.0-rc1 released!

Thu, 14 Jun 2012 19:33:18 +0000

Eigen 3.1.0-rc1 has been released on June 14, 2012.

This release candidate should be last milestone before we release Eigen 3.1 next week.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.0/eigen-3.1.0-rc1.tar.bz2

Since 3.1.0-beta1, the major change is the introduction of the Eigen::initParallel() function which must be called by multi-threaded user code to properly initialize Eigen and thus avoid the risk of a race condition.

Complete changelog.

Eigen 3.1.0-beta1 released!

Wed, 06 Jun 2012 20:47:07 +0000

Eigen 3.1.0-beta1 has been released on June 6, 2012.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.0/eigen-3.1.0-beta1.tar.bz2

This beta release introduces an incomplete LU preconditioner with dual thresholding, and an interface to the parallel PaStiX sparse solver (LLT, LDLT, LU). This release also includes the renaming of the SimplicialLLt and SimplicialLDLt classes to SimplicialLLT and SimplicialLDLT. Sparse-dense products have been slightly accelerated, while the support for permutation and self-adjoint view with sparse matrices has been significantly improved. This release also includes many bug fixes.

MKL Tips

Thu, 22 Mar 2012 20:10:23 +0000

Using MKL through environment module

A useful tip from rgriffin122 of the forum:

Using Eigen3.1.0 and MKL 10.3.7, I had to create two modules for proper compilation. The first one was an Intel_MKL module, designating the proper libraries and paths. The second was the Eigen module, which is doing the same thing as the Intel_MKL one, only for Eigen.

`Example:` `-----intel------` `#%Module 1.0` `2 #` `3 # Intel module for use with 'environment-modules' package:` `4 #` `5 ` `6 ## MKL ` `7 setenv MKLROOT /opt/mkl10.3.7/mkl` `8 setenv MKL_TARGET_ARCH intel64` `9 prepend-path LD_LIBRARY_PATH /opt/mkl10.3.7/mkl/lib/intel64` `10 prepend-path LIBRARY_PATH /opt/mkl10.3.7/mkl/lib/intel64` `11 prepend-path LD_LIBRARY_PATH /opt/mkl10.3.7/lib/intel64` `12 prepend-path LIBRARY_PATH /opt/mkl10.3.7/lib/intel64` `13 prepend-path NLSPATH /opt/mkl10.3.7/mkl/lib/intel64/locale/%l_%t/%N` `14 prepend-path MANPATH /opt/mkl10.3.7/man/en_US` `15 prepend-path INCLUDE /opt/mkl10.3.7/mkl/include` `16 prepend-path CPATH /opt/mkl10.3.7/mkl/include`
-----Eigen-----
1 #%Module 3.2
2 #
3 # Eigen with Intel MKL Blas and Lapack module
4 #
5 prereq intel-x86_64
6 prepend-path INCLUDE /opt/eigen3.1.0_MKL/include/eigen3
7 prepend-path CPATH /opt/eigen3.1.0_MKL/include/eigen3
8 prepend-path LD_LIBRARY_PATH /opt/eigen3.1.0_MKL/lib
9 prepend-path LIBRARY_PATH /opt/eigen3.1.0_MKL/lib
10 setenv EIGEN_ROOT /opt/eigen3.1.0_MKL/
11 setenv EIGEN_INFO eigen3.1.0_MKL

Eigen 3.0.5 released!

Fri, 10 Feb 2012 19:00:28 +0000

Eigen 3.0.5 has been released on February 10, 2012.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.0.5/eigen-3.0.5.tar.bz2

This is a maintenance release with various bug and warning fixes.

Complete changelog.

Eigen 3.1.0-alpha2 released with support for Intel MKL!

Mon, 06 Feb 2012 15:37:53 +0000

Eigen 3.1.0-alpha2 has been released on February 6, 2012.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.0/eigen-3.1.0-alpha2.tar.bz2

The key novelty of this alpha release is the possibility to fallback to Intel MKL (or another external BLAS library) for a couple of operations including matrix products (BLAS L2/L3), dense matrix decompositions (LAPACKE), and math array operations (via the Intel VML). These completely optional backends can be enabled through some compile-time preprocessor directives as explained in the respective manual page. In the same vein, this version also brings support for the Intel MKL PARDISO direct sparse solver. Recall that Intel MKL is proprietary software (see this notice).

Eigen 3.1.0-alpha1 released!

Tue, 06 Dec 2011 15:57:52 +0000

Eigen 3.1.0-alpha1 has been released on December 6, 2011.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.1.0/eigen-3.1.0-alpha1.tar.bz2

This alpha version of the future 3.1 finally brings to live a set of official sparse modules for the representation, assembly, and solving of sparse problems. A quick overview can be found in the manual while the changelog contains some details on the main differences with the unstable 3.0 sparse modules.

This alpha release also features closed-form algorithms for small eigenvalue problems, Cholesky updates/downdates, new coefficient-wise and vector-wise operators, as well as some performance and memory optimizations (for reductions and JacobiSVD respectively).

Eigen 3.0.4 released!

Tue, 06 Dec 2011 14:22:15 +0000

Eigen 3.0.4 has been released on December 6, 2011.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.0.4/eigen-3.0.4.tar.bz2

This fixes various compilation issues, alignment-related issues (crashes), adds checks for integer overflow when dealing with very large matrices, and fixes convergence in SelfAdjointEigenSolver.

Complete changelog.

Eigen 2.0.17 released!

Tue, 06 Dec 2011 14:20:29 +0000

Eigen 2.0.17 has been released on December 6, 2011.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/2.0.17/eigen-2.0.17.tar.bz2

This fixes a compilation issue with aligned_allocator, and a typo in the ParametrizedLine documentation.

Complete changelog.

Eigen 3.0.3 released!

Thu, 06 Oct 2011 19:48:13 +0000

Eigen 3.0.3 has been released on October 6, 2011.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.0.3/eigen-3.0.3.tar.bz2

This release fixes Eigen2 support which was broken by the previous release and a potentially serious bug in the evaluation of certain product expressions of a rare type. There are also some more minor fixes.

Complete changelog.

File:PCL logo.png

Mon, 19 Sep 2011 05:32:41 +0000

The logo of the Point Cloud Library (PCL) project.

Versatility

Thu, 08 Sep 2011 11:55:43 +0000

Versatility is a defining trait of Eigen as a matrix library.

Eigen supports matrices of very different sizes

Eigen fully supports very small (for example, 3x3) matrices whose size is known at compile time. The typical target audience here is games, graphics, vision, robotics. In this case, you want to avoid dynamic memory allocation and you want loops to be explicitly unrolled. Eigen does all of that. We’ve always believed that for these use cases, users would not tolerate even the slightest overhead, so our design allows to guarantee zero abstraction penalty for most operations on such small fixed-size objects.

Eigen 3.0.2 released!

Fri, 26 Aug 2011 13:11:37 +0000

Eigen 3.0.2 has been released on August 26, 2011.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.0.2/eigen-3.0.2.tar.bz2

Among various minor bug fixes, this release fixes some compilation issues with MinGW, improves the compliance to the C++ standard, and, for windows.h users, it is not necessary to #undef the min/max macros anymore.

Complete changelog.

Eigen 3.0.1 released!

Sun, 05 Jun 2011 21:32:43 +0000

Eigen 3.0.1 has been released on May 30, 2011.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/3.0.1/eigen-3.0.1.tar.bz2

In addition to various minor bug fixes, this release brings official support for gcc 4.6 and ARM NEON as well as an improved support for custom scalar types. The later includes exceptions safety and the automatic uses of the math functions declared in the scalar type’s namespace.

Complete changelog.

Eigen 2.0.16 released!

Sat, 28 May 2011 16:06:32 +0000

Eigen 2.0.15 has been released on July 16, 2010.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/2.0.16/eigen-2.0.16.tar.bz2

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.

Complete changelog.

Eigen 3.0.0 released!

Wed, 30 Mar 2011 14:08:08 +0000

Eigen 3.0 was released on March 19, 2011. See the detailed changelog.

Sandbox

Tue, 29 Mar 2011 13:09:29 +0000

Announcements

Paris 2011 Meeting

Mon, 21 Mar 2011 10:20:18 +0000

This meeting took in Paris, from Friday March 18 to Sunday March 20, 2011.

It was mostly dedicated to planning deep changes for Eigen 3.1: the expression evaluator.

Gael, Benoit, Jitse

Friday

Gael, Thomas and Benoit started working on the expression evaluator. A work plan was outlined on the whiteboard. A repository was created for implementing simple cases, while Gael worked on the tricky case of matrix products.

File:Eigen-meeting-2011-rescaled.jpeg

Mon, 21 Mar 2011 09:44:07 +0000

Todo

Sun, 20 Mar 2011 06:26:34 +0000

Eigen_Owl_Todo.jpg

This is the general, long-term Todo list, with a special emphasis on open jobs for new contributors to tackle. There is also a separate Todo for 3.0 aimed specifically at preparing Eigen 3.0.

Notice to prospective contributors

Before you start spending time on any of these items, contact us about it!

Sometimes the Todo is outdated
Sometimes some items in the todo haven’t been sufficiently discussed

So by contacting us you can avoid any bad surprise.

Meetings

Sun, 13 Feb 2011 21:08:23 +0000

Begles 2009

See http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2009/08/msg00006.html.

Paris 2010

See Paris 2010 Meeting.

Paris 2011

See Paris 2011 Meeting.

PythonInterop

Mon, 25 Oct 2010 11:32:29 +0000

Python interoperability is still in its infancy.

Here is an example of how to write a Boost::Python wrapper around one of your Eigen based classes: PythonInteropBoost

PyEigen is a very much work-in-progress set of Python bindings for Eigen.

Talk:Benchmark

Wed, 20 Oct 2010 12:12:45 +0000

Comment by Tvisitor

A few observations:

some (if not all?) of the benchmark calculations are done in single precission, ideally that should be changed to double
to calculate flops I would not count + and - operations but only * and /

so for mat*mat operation we would get n*n*n and not 2*n*n*n as used in the source code of the benchmark

double nb_op_base( void ){
return 2.0*_size*_size*_size;
}

CMake

Mon, 04 Oct 2010 00:24:53 +0000

CMake is a cross-platform tool to generate files for your platform’s native build system. For example, on Unix it generates Makefiles (so you subsequently use ‘make’), on Windows/MSVC it generates project files, etc.

CMake is most probably available for your platform, see their website. On Unix systems, it is probably available from your package manager.

CMake distinguishes between the source directory and the build directory:

The source directory is your checkout of the eigen repository. It contains a CMakeLists.txt file.
The build directory is a directory that you create yourself, and from which you run cmake. The first time you run cmake, pass it the path to the source directory. All CMake-generated files will go there.

The typical startup commands are:

BibTeX

Sat, 21 Aug 2010 14:35:18 +0000

Here’s a BibTeX entry for Eigen that you can use to cite Eigen in your academic publications:

@MISC{eigenweb,
  author = {Ga\"{e}l Guennebaud and Beno\^{i}t Jacob and others},
  title = {Eigen},
  howpublished = {https://libeigen.gitlab.io},
  year = {2010}
}

If you are using the Natbib package, we recommend using \citet* and \citep* instead of \citet and \citep, as the latter commands tend to keep only the first-named author and “others”.

The choice of the two main authors listed there is reasonable in general, but do feel free to use a different author field, for example if you think that in your particular case, you are relying on a feature developed by another author.

Eigen 2.0.15 released!

Fri, 16 Jul 2010 14:25:55 +0000

Eigen 2.0.15 has been released on July 16, 2010.

The source archive is at: https://gitlab.com/libeigen/eigen/-/archive/2.0.15/eigen-2.0.15.tar.bz2

Changes since 2.0.14:

  * Fix bug: a bad assert was blocking certain cases of matrix-vector product (depending on storage order).
  * 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).

Lapack

Tue, 06 Jul 2010 13:43:20 +0000

Interfacing Eigen with LAPACK

LAPACK is a large linear algebra library written in FORTRAN. It has loads of routines for all kinds of matrix problems so it is useful if you need something beyond the standard SVD, LU decomposition and so on. I needed to use it to solve the generalised eigen-problem in order to implement ellipse fitting. I shall use this as an example.

Choose your routine

All LAPACK functions have stupidly short names. Apparently it is a FORTRAN limitation. There is a list of names and what they do at the LAPACK page here: 1. The function I wanted was dggev which “Computes the generalized eigenvalues, and left and/or right generalized eigenvectors for a pair of nonsymmetric matrices”. Open the FORTRAN file for your chosen function and note the function parameters and their types. In my case it is:

File:Diagonal-matrix-hierarchy.png

Wed, 30 Jun 2010 17:22:16 +0000

Class hierarchy for a non-dense matrix (expression)

File:Array-expression-hierarchy.png

Wed, 30 Jun 2010 17:21:48 +0000

Class hierarchy for a dense array-expression

File:Matrix-expression-hierarchy.png

Wed, 30 Jun 2010 17:21:25 +0000

Class hierarchy for a dense matrix-expression

File:Array-hierarchy.png

Wed, 30 Jun 2010 17:20:59 +0000

Class hierarchy for a dense array

File:Matrix-hierarchy.png

Wed, 30 Jun 2010 17:20:31 +0000

Class hierarcy for a dense matrix

EigenInternals

Mon, 21 Jun 2010 14:51:35 +0000

owl_internal.jpg

Cost Model

Eigen internally implements a cost model to control at compile time both the evaluation of nested expressions and explicit unrolling. The read cost (RC) associated to an expression represents an approximation of the effective number of instructions needed to read or evaluate a single coefficient of the expression. Given the following notations:

SC = NumTraits::ReadCost
MC = NumTraits::MulCost
AC = NumTraits::AddCost

the cost of the expression 2*m1+m2 will be RC = (MC + SC) + AC + SC. For native types, we have SC==MC==AC==1, and then, in our example, we have RC = 4.

Documentation for Eigen3

Mon, 14 Jun 2010 18:01:42 +0000

Here is an outline for the documentation for Eigen3. The basics are from Benoit’s email and replies.

The documentation for Eigen3 consists of the following parts:

A super quick 5-minute “getting started” tutorial, similar to the beginning of our existing tutorial.

A long, detailed 1-hour tutorial, of perhaps 4-8 pages, taking the time to explain some basic concepts, with lots of links to the other pages:
- Simple example with fixed-size matrix, to get started. How to “install” Eigen, how to compile the example.
- Accessing the entries of a matrix.
- Initializing the matrix. Special matrices (refer to “cheat sheet”), comma initializer.
- Dynamic-size matrices. Simple example. How to specify the size (constructor, assignment, resize).
- Matrix operations; some examples with rest in “cheat sheet”
- Vectors, and where they differ from matrices.
- The three template parameters of the Matrix templates, and the standard typedefs.
- Arrays, and where they differ from matrices/vectors.
- Output.
- Matrix blocks.
- The Map class. Interfacing with other libraries / code.
- How to handle matrices of special shape (diagonal, triangular, symmetric, band).
- Organization of header files / modules. Summary of modules provided.
- Summary of special topic pages.

A set of topical “cheat sheets”, basically like most of current tutorial, just updated, and freed from the requirement of being actually a tutorial - this just has to be a reference, since the tutorial role is taken over by other pages. Also see ASCII quick reference.
- List cheat sheets here

Doxygen pages on specific topics, like https://libeigen.gitlab.io/eigen/docs-nightly/TopicLazyEvaluation.html . These may overlap a bit, the goal is to make info easy to find.
- What member data is inside of a Matrix/Array? What’s the memory layout? Is it heap allocated? People want to know how to interact with other libs, and want to know if Eigen incurs any memory overhead (esp. in the fixed-size case). Knowing that a Matrix is just a dumb array of coeffs, will also help people understand stuff.
- Storage orders. What’s the default? How to use row-major? How to set it as the default? When evaluating m.transpose(), what storage order is used? What about the special case of Vectors, can a row-vector be column-major storage order (hint: no it can’t, vectors MUST have the “right” storage order or you get a compilation error).
- Memory allocation, even if that will overlap with many other pages, because many people will be looking for info about that. What causes heap allocation? Mention aligned malloc too. That page should perhaps be mostly just links to other pages. See Talk:FAQ for a start.
- Sizes at compile time. The constant Dynamic. The Max-sizes. The link between the Max-sizes and memory allocation: the fact that Matrix4f().block(…).eval() doesn’t cause a heap allocation. Block(…) is the perfect example for the Max-sizes.
- Alignment, aligned malloc, alignment qualifiers, the issues that that can cause (link to the unaligned assert’s pages)
- Expression templates, lazy evaluation etc.
- Aliasing, eval(), noalias().
- Writing one’s own expression classes; inheriting from Matrix and other Eigen classes.
- The overall design and class hierarchy, the role of MatrixBase and other base classes, the standard typedefs such as PlainMatrixType and Scalar…
- Writing functions that take matrices as arguments and/or return them. What prototype to use? Matrix or MatrixBase? (perhaps combine with point above)
- Compile-time switches (preprocessor symbols like EIGEN_NO_DEBUG etc)
- Compiler support/options and Vectorization : also see coverage in the FAQ
- Thread safety
- Usage with OpenGL
- The existing “special topics” pages need to be updated and/or replaced.

Each non-Core module needs its own dox page.
- Cholesky module
- Eigenvalues module
- Geometry module; see https://libeigen.gitlab.io/eigen/docs-3.0/TutorialGeometry.html
- Householder module
- Jacobi module
- LU module
- QR module
- Sparse module; see https://libeigen.gitlab.io/eigen/docs-3.0/TutorialSparse.html
- SVD module

The API pages generated by doxygen.

This wiki is used to supplement the documentation. Information available here can be converted to the doxygen docs if necessary / required.

Paris 2010 Meeting

Fri, 07 May 2010 13:11:51 +0000

The meeting was held in Paris, from Friday, February 19, to Sunday, February 21, 2010.

This was the first real meeting of the Eigen team (except of course for the huge 2009 World Conference).

Lots of discussion and development happened to prepare the upcoming 3.0 release, as well as more long-term items such as the beginning of SMP support within Eigen.

On Friday, we got the visit of Dodji Seketli from Red Hat, who introduced us to some GCC internals, and of Joel Falcou from Université Paris Sud who presented NT2.

Talk:FAQ

Mon, 03 May 2010 04:51:43 +0000

WARNING!!! THE FOLLOWING IS A DRAFT OF PROPOSED FAQ ADDITIONS AND IS STILL UNDERGOING FACT CHECKING!

Memory Management

What actions trigger dynamic memory allocation?

If the size of a MatrixXf isnt known at compile time, the only way to create it is on the heap:

MatrixXf x = MatrixXf::Zero(rows, cols);

x.setZero(int, int) and friends, when the new size is greater or smaller than the old size.
conservative resize functions, again only when the new size is greater or smaller than the old size.
Temporary variables in expressions

Dynamic allocation only when their size is not known at compile time and not even a reasonable upper bound on their size is known at compile time. For example,

PythonInteropBoost

Thu, 29 Apr 2010 22:29:37 +0000

This is an example of one way to wrap an Eigen-based C++ class using Boost::Python for use with numpy.

Here is an overview of how it works:

You write a wrapper function for any member functions that take Eigen Matrices,Vectors,etc… This function will:
- take PyObjects (your numpy arrays) as inputs,
- use a macro to get at the underlying data,
- use Eigen’s Map functionality to “turn them into” Eigen arrays,
- and then call the wrapped function using these arrays.
You write a bit more code to tell Boost about your class and the functions you are exposing to python.
You build the module as a shared library
You can either:
- import this directly in your code (you will crash hard if the inputs are incorrect) or
- write some Python to do typechecking, bounds checking, etc… in __init__.py, exporting a “safe” version to the rest of your code. (the example does this)

All in all, this is definitely overkill for the included example, and hopefully some day there will be a much cleaner way of doing this, but this is a place to start, and may even be satisfactory if you are already familiar with Boost::Python.

File:Silly professor2.jpg

Wed, 03 Mar 2010 15:58:15 +0000

Attempt to capture the style of David Benjamin’s Silly Professor with reduced complexity

Working notes - SMP support

Tue, 23 Feb 2010 15:30:27 +0000

Some developments started in a fork using OpenMP.

Underlying threading model

Possibilities:

OpenMP
- pro:
  - easy to implement
  - easy to enable for the user (compiler flag)
- cons:
  - difficult to control the generated code => difficult to control the overhead
pthreads
- pro:
  - everything is possible
  - should not be too hard to use for our relatively simple use cases
- cons:
  - a bit more work for us
Intel’s TBB
- I see only cons:
  - Too high level for our purpose.
  - Not free

API

We need to figure out how to easily control the parallelization. Goals:

File:Meeting-paris-2010-rescaled.jpeg

Mon, 22 Feb 2010 20:10:05 +0000

Eigen 2

Sun, 17 Jan 2010 20:30:36 +0000

This page is about the outdated version 2 of Eigen.

We highly recommended to port any existing code which is still using Eigen 2 to Eigen 3. To this end, follow our porting guide. Morover, note that the module and compatibility modes will be removed in Eigen 3.3.

Useful links:

Eigen 2.0.17 downloads: tar.bz2, tar.gz, zip.
Eigen 2.0.17 Changelog.
Eigen 2 documentation

Eigen2 benchmark Intel

Mon, 14 Dec 2009 16:07:04 +0000

Out of curiosity, I have performed BTL tests with Eigen2 compiled with 4 different compilers on Intel Pentium D CPU:

GCC 4.3.3: -O3 -march=native -DNDEBUG
GCC 4.1.3: -O3 -march=nocona -msse2 -msse3 -DNDEBUG
GCC 4.4.0: -O3 -march=native -DNDEBUG
Intel(R) C++ 11.0: -O3 -DNDEBUG -no-ipo -xHOST -ip -static -no-prec-div

Although from on my experience the -ipo option (interprocedural optimization) provides good performance benefits, it was explicitly disabled for Intel, because it failed to work (numerically).

EigenFFT

Wed, 25 Nov 2009 03:44:11 +0000

Eigen/FFT is a WORK IN PROGRESS

A new effort was started in May 2009 to port/adapt the kissfft library to Eigen. The work is currently in the unsupported section.

Help is welcome. In particular, help is needed in the area of

testing and feedback on how to make the interface better
creating IMKL backend

The major development milestones are:

DONE: one-dimensional FFTs, forward and inverse for float, double,long double
DONE: real-only optimization
TODO: multi-dimensional FFTs ( more cannibalizing from C version)
DONE: backend for FFTW ( using this requires GPL-compatible application, or the commercial MIT license for FFTW)
TODO: backend for intel Math Kernel Library (for closed source applications)

Example usage

#include <unsupported/Eigen/FFT>

File:Eigen debug.jpg

Fri, 16 Oct 2009 15:23:19 +0000

Functors

Sat, 26 Sep 2009 19:51:34 +0000

In pure C, when one wants to pass a function as parameter to another function, one passes its address. However, in C++ this technique should generally not be used, as one can do much better.

__TOC__

The functors approach with static polymorphism

One can define a class “functor” that contains the wanted function as a method, and pass an object of class “functor” instead. If the function needed to take arguments, they can be passed to the constructor of “functor” and stored in the functor object. The compiler is typically very good at optimizing this away when possible. Here’s an example:

Tuxfamily

Thu, 24 Sep 2009 16:01:31 +0000

What is Tuxfamily ?

Tuxfamily is a nonprofit organisation providing hosting services to thousands of Free Software projects. For Eigen, it provides the web server, the download server (supporting really large bandwidth), the MySQL server (for our wiki) and the mailing lists.

All with an excellent quality of service, without advertising and without fees. It is run entirely by a merry group of volunteers in their free time, and the software infrastructure which they develop, VHFFS, is itself Free Software. So, we Eigen developers thought we’d just mention it and perhaps encourage you to contribute to the Tuxfamily project.

SparseMatrix

Wed, 23 Sep 2009 21:13:40 +0000

WARNING: this page is mostly out of date.

Preliminaries

CCS stands for Compressed Column Storage. It is the most common sparse storage scheme (see http://netlib.org/linalg/html_templates/node90.html).
CRS: Compressed Row Storage, like CCS but row major
nnz: number of nonzero entries

What’s the plan ?

Ideally:

define our own classes for storage and basic algebra (sum, product, triangular solver)
a good support of CCS/CRS sparse matrix is certainly the priority as it is the most common storage format
we could probably adapt the linear solver algorithms of GMM++ (or ITL) to directly use our matrix classes
- see the licensing issues
provide the ability to use more optimized backends like TAUCS or SuperLU as well as backends for eigen value solvers via a unified API

Current state

For the first step the goal is to focus on CCS (CRS) sparse matrix. See the class SparseMatrix.

Talk:Main Page

Tue, 22 Sep 2009 15:07:48 +0000

Wiped. See history.

File:Eigen Silly Professor 35x35.png

Sat, 16 May 2009 15:57:21 +0000

SpecialMatrix

Thu, 30 Apr 2009 13:51:42 +0000

Here are some random thoughts about this topic.

Overview of each matrix type

Triangular matrix and SelfAdjoint matrix

Currently in core.

We have the “view as” concept (currently implemented in Part) which has 2 different behaviors:

1 - in write mode, it allows to update (resp. evaluate) only one part of the lhs matrix (resp. rhs expression). This works quite well (have to check vectorization). Ex:

Benchmark AMD Intel compare

Tue, 17 Mar 2009 07:15:10 +0000

This page presents benchmark results on both Intel and AMD CPUs. See Benchmark_Intel and Benchmark_AMD.

17 February 2009

Configuration:

Compiler: gcc version 4.3.3 [gcc-4_3-branch revision 143673] (OpenSUSE 11.1 64-bit)

Libraries:

eigen2: Revision: 939062. SSE2, SSE3 enabled
ACML: version 4.2.0 compiled with gfortran
MKL: version 10.1
Goto BLAS: version 1.26
ATLAS: version 3.8.3

Intel(R) Pentium(R) D CPU 3.00GHz (model name: Prescott)	AMD Athlon(tm) 64 X2 Dual Core Processor 5000+
Axpy_intel.png	Axpy_amd.png
Axpby_intel.png	Axpby_amd.png
Atv_intel.png	Atv_amd.png
Matrix_vector_intel.png	Matrix_vector_amd.png
Matrix_matrix_intel.png	Matrix_matrix_amd.png
Symv_intel.png	Symv_amd.png
Syr2_intel.png	Syr2_amd.png
Aat_intel.png	Aat_amd.png
Ata_intel.png	Ata_amd.png
Trisolve_intel.png	Trisolve_amd.png
Cholesky_intel.png	Cholesky_amd.png
Hessenberg_intel.png	Hessenberg_amd.png
Tridiagonalization_intel.png	Tridiagonalization_amd.png
Lu_decomp_intel.png	Lu_decomp_amd.png

Benchmark AMD

Tue, 17 Mar 2009 06:48:35 +0000

The purpose of this page is to show the comparison of the best performing BLAS/LAPACK implementations and Eigen2 on an AMD Athlon(tm) 64 X2 CPU. By best performing I mean Intel MKL, GotoBLAS, ATLAS, and ACML (by AMD). Other implementations of BLAS/LAPACK are notably slower (see benchmark) and therefore not worth testing (and using). ACML was not included in the original benchmark.

13 February 2009

Configuration:

CPU: AMD Athlon(tm) 64 X2 Dual Core Processor 5000+
Compiler: gcc version 4.3.3 [gcc-4_3-branch revision 143673] (OpenSUSE 11.1 64-bit)

Libraries:

File:Trisolve amd.png

Tue, 17 Mar 2009 06:45:17 +0000

File:Tridiagonalization amd.png

Tue, 17 Mar 2009 06:44:59 +0000

File:Syr2 amd.png

Tue, 17 Mar 2009 06:44:41 +0000

File:Symv amd.png

Tue, 17 Mar 2009 06:44:24 +0000

File:Matrix vector amd.png

Tue, 17 Mar 2009 06:43:51 +0000

File:Matrix matrix amd.png

Tue, 17 Mar 2009 06:42:57 +0000

File:Lu decomp amd.png

Tue, 17 Mar 2009 06:42:30 +0000

File:Hessenberg amd.png

Tue, 17 Mar 2009 06:42:08 +0000

File:Cholesky amd.png

Tue, 17 Mar 2009 06:41:46 +0000

File:Axpy amd.png

Tue, 17 Mar 2009 06:41:11 +0000

File:Axpby amd.png

Tue, 17 Mar 2009 06:40:51 +0000

File:Atv amd.png

Tue, 17 Mar 2009 06:40:28 +0000

File:Ata amd.png

Tue, 17 Mar 2009 06:40:09 +0000

File:Aat amd.png

Tue, 17 Mar 2009 06:39:00 +0000

File:Trisolve compare intel.png

Tue, 17 Mar 2009 02:27:45 +0000

File:Tridiagonalization compare intel.png

Tue, 17 Mar 2009 02:27:27 +0000

File:Syr2 compare intel.png

Tue, 17 Mar 2009 02:26:58 +0000

File:Symv compare intel.png

Tue, 17 Mar 2009 02:26:41 +0000

File:Matrix vector compare intel.png

Tue, 17 Mar 2009 02:26:16 +0000

File:Matrix trisolve compare intel.png

Tue, 17 Mar 2009 02:25:40 +0000

File:Matrix matrix compare intel.png

Tue, 17 Mar 2009 02:22:52 +0000

File:Lu decomp compare intel.png

Tue, 17 Mar 2009 02:22:28 +0000

File:Hessenberg compare intel.png

Tue, 17 Mar 2009 02:22:08 +0000

File:Cholesky compare intel.png

Tue, 17 Mar 2009 02:21:26 +0000

File:Axpy compare intel.png

Tue, 17 Mar 2009 02:20:30 +0000

File:Axpby compare intel.png

Tue, 17 Mar 2009 02:19:46 +0000

File:Atv compare intel.png

Tue, 17 Mar 2009 02:19:25 +0000

File:Ata compare intel.png

Tue, 17 Mar 2009 02:18:45 +0000

File:Aat compare intel.png

Tue, 17 Mar 2009 02:15:48 +0000

Benchmark Intel

Sun, 15 Mar 2009 03:28:39 +0000

The purpose of this page is to show the comparison of the best performing BLAS/LAPACK implementations and Eigen2 on an Intel(R) Pentium(R) D CPU. By best performing I mean Intel MKL, GotoBLAS, ATLAS, and ACML (by AMD). Other implementations of BLAS/LAPACK are notably slower (see benchmark) and therefore not worth testing (and using). ACML was not included in the original benchmark.

13 February 2009

Configuration:

CPU: Intel(R) Pentium(R) D CPU 3.00GHz (model name: Prescott)
Compiler: gcc version 4.3.3 [gcc-4_3-branch revision 143673] (OpenSUSE 11.1 64-bit)

Libraries:

File:Trisolve intel.png

Sat, 14 Mar 2009 05:36:50 +0000

File:Tridiagonalization intel.png

Sat, 14 Mar 2009 05:36:23 +0000

File:Syr2 intel.png

Sat, 14 Mar 2009 05:35:59 +0000

File:Symv intel.png

Sat, 14 Mar 2009 05:34:51 +0000

File:Matrix vector intel.png

Sat, 14 Mar 2009 05:34:11 +0000

File:Matrix matrix intel.png

Sat, 14 Mar 2009 05:33:32 +0000

File:Lu decomp intel.png

Sat, 14 Mar 2009 05:26:43 +0000

File:Hessenberg intel.png

Sat, 14 Mar 2009 05:26:01 +0000

File:Cholesky intel.png

Sat, 14 Mar 2009 05:25:17 +0000

File:Axpy intel.png

Sat, 14 Mar 2009 05:23:14 +0000

File:Axpby intel.png

Sat, 14 Mar 2009 05:21:34 +0000

File:Atv intel.png

Sat, 14 Mar 2009 05:20:01 +0000

File:Ata intel.png

Sat, 14 Mar 2009 05:18:24 +0000

File:Aat intel.png

Sat, 14 Mar 2009 05:17:00 +0000

File:Aat.png

Sat, 14 Mar 2009 05:15:46 +0000

UsingVector4fForVector3fOperations

Thu, 12 Mar 2009 13:01:47 +0000

In many cases, one needs to use the Vector3f class (in 3D codes, for instance). However, since it is not a multiple of 16 bytes, you do not get the benefit of vectorization. However, in certain instances, you may be able to simply use a Vector4f class with the last component set to zero to use vectorization. For component wise operations such as add, subtract and multiply, you can of course blissfully ignore the last component. However, for dot and cross products and normalization operations, you will need to have the w component set to 0.

File:Owl internal.jpg

Thu, 18 Dec 2008 14:17:39 +0000

File:Owl faq.jpg

Thu, 18 Dec 2008 14:17:06 +0000

File:Axpy.png

Sat, 12 Jul 2008 13:39:32 +0000

bench results for Y += A * X

File:Matrix vector.png

Sat, 12 Jul 2008 13:29:42 +0000

bench result of matrix vector product.

Expression templates

Fri, 11 Jul 2008 17:25:05 +0000

Expression templates refers to a c++ coding technique that was discovered in the 90’s, which can greatly improve the performance and the API cleanness and expressiveness of certain kinds of c++ template libraries, and is especially useful for a vector/matrix library such as Eigen. First, some links: wikibooks and the links given there.

Motivation : better performance through lazy evaluation

Suppose that we want to write a 3D Vector class. The standard approach is:

File:Eigen Silly Professor 135x135.png

Thu, 29 May 2008 03:51:26 +0000

Our mascot!

File:Eigen Silly Professor 135x135.jpg

Wed, 16 Apr 2008 17:34:02 +0000

File:Eigen Owl Todo.jpg

Wed, 16 Apr 2008 17:33:15 +0000

Mon, 01 Jan 0001 00:00:00 +0000

====== Première journée scientifique ======

{{:animation_scientifique:journeessci:2011-emailing_journee_plafrim.jpg?600}}

31 mai 2011 - Amphi du LaBRI - Bât A30

Déjà un an que PlaFRIM, la plateforme d’expérimentation autour de la modélisation et du calcul à hautes performances est opérationnelle. Celle-ci regroupe des compétences variées autour des mathématiques appliquées et de l’informatique. Nous vous proposons de participer à la première journée scientifique qui lui est dédiée le <fc #FF0000>mardi 31 mai 2011, afin de faire le point sur les travaux réalisés sur la plateforme et d’avoir un retour d’expérience. ===== Programme =====